Update app.py

app.py

@@ -1,63 +1,68 @@
 """
-US Value Intelligence v3 — Compact Value & Intrinsic Valuation Platform
-=========================================================================
-Data integrity > model complexity. Intrinsic value > momentum. Margin of safety > prediction.
-
-Veri etiketleri:  [R] raporlanan   [D] türetilen   [A] kullanıcı varsayımı
-UYARI: yfinance verisi point-in-time DEĞİLDİR; backtest için kullanılamaz.
+OKX Value Intelligence v1 — Compact Fair-Value & Risk Platform (OKX Spot, USDT pairs)
+======================================================================================
+Data integrity > model complexity. Fair value > momentum. Margin of safety > prediction.
+
+Veri kaynağı: OKX public REST API (anahtar gerekmez) — spot ticker, günlük mumlar, perp funding / open interest.
+Veri etiketleri:  [R] OKX'ten alınan   [D] türetilen   [A] kullanıcı varsayımı
+UYARI: Kripto varlıkların bilançosu/nakit akışı yoktur. "Fair value" fiyat-hacim verisinden türetilen
+istatistiksel referanstır (içsel değer değildir). Backtest/yatırım tavsiyesi değildir.
 """
 
 import logging
+import math
 import tempfile
 import time
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 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 requests
 
 logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
-logger = logging.getLogger("us_v3")
-
-US_UNIVERSE = [
-    # Teknoloji
-    "AAPL", "MSFT", "NVDA", "GOOGL", "META", "AVGO", "ORCL", "ADBE", "CRM", "CSCO",
-    "INTC", "AMD", "QCOM", "TXN", "IBM", "INTU", "AMAT", "MU", "NOW", "ACN",
-    # Tüketici
-    "AMZN", "TSLA", "HD", "MCD", "NKE", "SBUX", "LOW", "TJX", "COST", "WMT",
-    "PG", "KO", "PEP", "PM", "MO", "MDLZ", "CL", "TGT",
-    # Sağlık
-    "UNH", "JNJ", "LLY", "PFE", "MRK", "ABBV", "TMO", "ABT", "DHR", "BMY",
-    "AMGN", "GILD", "MDT", "CVS", "ISRG",
-    # Bankalar
-    "JPM", "BAC", "WFC", "C", "GS", "MS", "USB", "PNC", "TFC", "SCHW", "BK",
-    # Sigorta
-    "BRK-B", "PGR", "CB", "MMC", "AIG", "MET", "PRU", "ALL", "TRV", "AFL",
-    # Sanayi
-    "CAT", "DE", "HON", "GE", "UPS", "UNP", "RTX", "LMT", "BA", "MMM",
-    "FDX", "EMR", "ETN", "ITW", "WM",
-    # Enerji
-    "XOM", "CVX", "COP", "SLB", "EOG", "OXY", "PSX", "MPC", "KMI",
-    # Kamu hizmetleri
-    "NEE", "DUK", "SO", "D", "AEP",
-    # Malzeme
-    "LIN", "SHW", "APD", "NEM", "FCX", "DOW", "NUE",
-    # REIT
-    "PLD", "AMT", "EQIX", "O", "SPG", "PSA", "WELL", "DLR", "CCI",
-    # İletişim / medya
-    "T", "VZ", "CMCSA", "DIS", "NFLX", "TMUS",
-]
-US_UNIVERSE = list(dict.fromkeys(US_UNIVERSE))  # tekrarları temizle
-assert len(US_UNIVERSE) >= 100, f"Evren {len(US_UNIVERSE)} hisse; en az 100 olmalı"
-
-REQUEST_DELAY_SEC = 0.3
-CACHE_TTL_HOURS = 6
+logger = logging.getLogger("okx_v1")
+
+# ============================================================================
+# CONFIG & UNIVERSE
+# ============================================================================
+
+OKX_BASE = "https://www.okx.com"
+REQUEST_DELAY_SEC = 0.12          # OKX public limit: 20 req / 2 s per endpoint
+CACHE_TTL_HOURS = 1
+LOOKBACK_DAYS = 500               # günlük mum derinliği (300 + 2x100 sayfa)
 MIN_PEERS = 5
+DEFAULT_UNIVERSE_N = 100
+MIN_VOL_USDT = 1_000_000          # 24s hacim alt sınırı (evren filtresi)
+
+STABLES = {"USDC", "DAI", "TUSD", "FDUSD", "USDE", "PYUSD", "USDG", "USDD", "EURC", "BUSD", "USTC", "USDP", "EURT", "XAUT"}
+
+# Kategori (segment) haritası — listede olmayan varlıklar "Other"
+CATEGORY_MAP = {
+    "Majors": ["BTC", "ETH", "SOL", "XRP", "BNB", "ADA", "TRX", "LTC", "BCH", "AVAX", "DOT", "TON"],
+    "Alt L1": ["ATOM", "NEAR", "APT", "SUI", "SEI", "ALGO", "ICP", "FIL", "HBAR", "XLM", "ETC", "EOS", "XTZ", "VET",
+               "THETA", "TIA", "KAS", "MINA", "FLOW", "S", "FTM", "KAVA", "CFX", "EGLD"],
+    "DeFi": ["UNI", "AAVE", "MKR", "LDO", "CRV", "SNX", "COMP", "DYDX", "INJ", "JUP", "ENA", "ONDO", "PENDLE", "1INCH",
+             "SUSHI", "CAKE", "RUNE", "GMX", "ETHFI", "EIGEN"],
+    "Infra/L2": ["ARB", "OP", "POL", "MATIC", "LINK", "GRT", "STX", "IMX", "STRK", "ZK", "MNT", "PYTH", "API3", "W", "BLUR", "ZRO"],
+    "Meme": ["DOGE", "SHIB", "PEPE", "WIF", "BONK", "FLOKI", "TRUMP", "PNUT", "MEME", "TURBO", "NEIRO", "BOME", "MEW", "ORDI"],
+    "AI/Gaming": ["FET", "RENDER", "RNDR", "WLD", "TAO", "AGIX", "OCEAN", "AR", "SAND", "MANA", "AXS", "GALA", "APE", "ENS", "AIXBT", "VIRTUAL"],
+}
+CATEGORY = {b: cat for cat, bases in CATEGORY_MAP.items() for b in bases}
+SEGMENTS = list(CATEGORY_MAP.keys()) + ["Other"]
+
+FALLBACK_BASES = ["BTC", "ETH", "SOL", "XRP", "DOGE", "ADA", "AVAX", "LINK", "DOT", "LTC", "BCH", "TRX", "UNI", "ATOM",
+                  "NEAR", "APT", "ARB", "OP", "SUI", "FIL", "ICP", "ETC", "XLM", "HBAR", "AAVE", "MKR", "LDO", "INJ",
+                  "SHIB", "PEPE", "WIF", "BONK", "FET", "RENDER", "GRT", "IMX", "SAND", "MANA", "TIA", "SEI"]
+
 _cache: Dict[str, Tuple[datetime, Any]] = {}
-LAST: Dict[str, Any] = {"df": None, "failed": []}
+_TICK: Dict[str, Any] = {"ts": 0.0, "data": {}}
+SETTINGS: Dict[str, Any] = {"perp": True}
+LAST: Dict[str, Any] = {"df": None, "failed": [], "universe": []}
+_session = requests.Session()
+_session.headers.update({"User-Agent": "okx-value-intelligence/1.0"})
 
 
 def _cget(k):
@@ -78,7 +83,7 @@ def _cset(k, v):
 
 def num(x) -> Optional[float]:
     try:
-        if x is None:
+        if x is None or x == "":
             return None
         v = float(x)
         return None if (np.isnan(v) or np.isinf(v)) else v
@@ -93,13 +98,6 @@ def div(a, b) -> Optional[float]:
     return a / b
 
 
-def growth(cur, prev) -> Optional[float]:
-    cur, prev = num(cur), num(prev)
-    if cur is None or prev is None or prev <= 0:
-        return None
-    return cur / prev - 1
-
-
 def real_ret(nominal, infl) -> Optional[float]:
     return None if nominal is None else (1 + nominal) / (1 + infl) - 1
 
@@ -129,205 +127,316 @@ def fm(x, d=2):
     return "N/A" if x is None else f"{x:,.{d}f}"
 
 
+def fpx(x):
+    """Fiyat biçimi: BTC (100k) ile PEPE (0.00001) aynı yerde okunabilsin."""
+    if x is None:
+        return "N/A"
+    a = abs(x)
+    if a >= 1000:
+        return f"{x:,.0f}"
+    if a >= 1:
+        return f"{x:,.2f}"
+    if a >= 0.01:
+        return f"{x:.4f}"
+    return f"{x:.4g}"
+
+
+def rsig(x, n=5):
+    return None if x is None else float(f"{x:.{n}g}")
+
+
 def fp(x, d=1):
     return "N/A" if x is None else f"{x * 100:.{d}f}%"
 
 
+def pct(x, d=1):
+    return None if x is None else round(x * 100, d)
+
+
 def norm_sym(t: str) -> str:
-    t = (t or "").strip().upper().replace(".", "-")  # Yahoo: BRK.B -> BRK-B
-    return t
+    """'btc', 'eth/usdt', 'SOLUSDT', 'BTC-USDT-SWAP' -> OKX spot instId (BTC-USDT)."""
+    s = (t or "").strip().upper().replace("/", "-").replace("_", "-").replace(" ", "")
+    if not s:
+        return ""
+    if s.endswith("-SWAP"):
+        s = s[:-5]
+    if "-" in s:
+        parts = s.split("-")
+        return f"{parts[0]}-{parts[1]}" if len(parts) >= 2 and parts[1] else f"{parts[0]}-USDT"
+    for q in ("USDT", "USDC"):
+        if s.endswith(q) and len(s) > len(q):
+            return f"{s[:-len(q)]}-{q}"
+    return f"{s}-USDT"
 
 
 def mk_params(infl, rw, rtg, rg, pt, cv) -> Dict[str, float]:
     return dict(infl=infl / 100, rw=rw / 100, rtg=rtg / 100, rg=rg / 100, pt=pt / 100, conv=cv / 100)
 
 
+def tier_of(v: Optional[float]) -> str:
+    if v is None:
+        return "Tier-4 (<5M)"
+    if v >= 100e6:
+        return "Tier-1 (≥100M)"
+    if v >= 20e6:
+        return "Tier-2 (20-100M)"
+    if v >= 5e6:
+        return "Tier-3 (5-20M)"
+    return "Tier-4 (<5M)"
+
+
 # ============================================================================
-# DATA ACQUISITION & INTEGRITY
+# OKX DATA ACQUISITION
 # ============================================================================
 
-STMT = {
-    "ni": (("Net Income", "Net Income Common Stockholders"), "fin"),
-    "rev": (("Total Revenue", "Operating Revenue"), "fin"),
-    "gp": (("Gross Profit",), "fin"),
-    "opinc": (("Operating Income", "EBIT"), "fin"),
-    "ebitda": (("EBITDA", "Normalized EBITDA"), "fin"),
-    "interest": (("Interest Expense", "Interest Expense Non Operating"), "fin"),
-    "tax": (("Tax Provision",), "fin"),
-    "pretax": (("Pretax Income",), "fin"),
-    "ta": (("Total Assets",), "bs"),
-    "eq": (("Stockholders Equity", "Common Stock Equity", "Total Equity Gross Minority Interest"), "bs"),
-    "debt": (("Total Debt",), "bs"),
-    "ltd": (("Long Term Debt", "Long Term Debt And Capital Lease Obligation"), "bs"),
-    "cash": (("Cash Cash Equivalents And Short Term Investments", "Cash And Cash Equivalents"), "bs"),
-    "ca": (("Current Assets",), "bs"),
-    "cl": (("Current Liabilities",), "bs"),
-    "shares": (("Ordinary Shares Number", "Share Issued"), "bs"),
-    "cfo": (("Operating Cash Flow", "Cash Flow From Continuing Operating Activities"), "cf"),
-    "capex": (("Capital Expenditure",), "cf"),
-    "fcf": (("Free Cash Flow",), "cf"),
-    "da": (("Depreciation And Amortization", "Depreciation Amortization Depletion"), "cf"),
-    "dwc": (("Change In Working Capital",), "cf"),
-}
+def okx_get(path: str, params: Optional[Dict[str, str]] = None, retries: int = 3) -> Optional[List[Any]]:
+    """OKX v5 public GET. Returns list (maybe empty) on success, None on failure."""
+    url = OKX_BASE + path
+    for k in range(retries):
+        try:
+            r = _session.get(url, params=params, timeout=15)
+            if r.status_code == 429:
+                time.sleep(1.0 * (k + 1))
+                continue
+            r.raise_for_status()
+            j = r.json()
+            code = str(j.get("code"))
+            if code == "0":
+                return j.get("data") or []
+            if code == "50011":  # rate limit
+                time.sleep(1.0 * (k + 1))
+                continue
+            logger.debug("OKX %s %s -> code %s %s", path, params, code, j.get("msg"))
+            return None
+        except Exception as e:
+            logger.warning("OKX %s failed (%s/%s): %s", path, k + 1, retries, e)
+            time.sleep(0.5 * (k + 1))
+    return None
 
 
-def stmt(df, names, i=0) -> Optional[float]:
-    if df is None or getattr(df, "empty", True) or i >= df.shape[1]:
-        return None
-    for n in names:
-        if n in df.index:
-            r = df.loc[n]
-            if isinstance(r, pd.DataFrame):
-                r = r.iloc[0]
-            return num(r.iloc[i])
-    return None
+def get_tickers(force: bool = False) -> Dict[str, Dict[str, Any]]:
+    if not force and _TICK["data"] and time.time() - _TICK["ts"] < 120:
+        return _TICK["data"]
+    rows = okx_get("/api/v5/market/tickers", {"instType": "SPOT"})
+    if rows:
+        _TICK["data"] = {r["instId"]: r for r in rows if r.get("instId")}
+        _TICK["ts"] = time.time()
+    return _TICK["data"]
 
 
-def segment_of(industry: str, sym: str) -> str:
-    ind = (industry or "").lower()
-    if "bank" in ind:
-        return "Bank"
-    if "insurance" in ind:
-        return "Insurance"
-    if "reit" in ind or "real estate" in ind:
-        return "REIT"
-    return "Industrial"
+def is_excluded(base: str) -> bool:
+    return base in STABLES or base.endswith(("3L", "3S", "5L", "5S"))
 
 
-def fetch(symbol: str, force: bool = False) -> Optional[Dict[str, Any]]:
-    key = f"t_{symbol}"
+def build_universe(n: int = DEFAULT_UNIVERSE_N) -> Tuple[List[str], str]:
+    """Top-N OKX spot USDT pairs by 24h quote volume (stablecoin / leveraged tokens excluded)."""
+    tk = get_tickers(force=True)
+    rows = []
+    for inst, r in tk.items():
+        if not inst.endswith("-USDT"):
+            continue
+        if is_excluded(inst[:-5]):
+            continue
+        v = num(r.get("volCcy24h"))  # SPOT: quote currency (USDT) cinsinden 24s hacim
+        if v is None or v < MIN_VOL_USDT:
+            continue
+        rows.append((v, inst))
+    rows.sort(reverse=True)
+    if rows:
+        return [i for _, i in rows[:n]], "OKX tickers (24s hacme göre)"
+    return [f"{b}-USDT" for b in FALLBACK_BASES][:n], "⚠️ ticker listesi alınamadı → gömülü yedek liste"
+
+
+def fetch_candles(inst: str, n: int = LOOKBACK_DAYS) -> Optional[pd.DataFrame]:
+    rows = okx_get("/api/v5/market/candles", {"instId": inst, "bar": "1D", "limit": "300"})
+    if not rows:
+        return None
+    allr = list(rows)
+    oldest = int(rows[-1][0])
+    while len(allr) < n:
+        time.sleep(REQUEST_DELAY_SEC)
+        more = okx_get("/api/v5/market/history-candles", {"instId": inst, "bar": "1D", "after": str(oldest), "limit": "100"})
+        if not more:
+            break
+        allr.extend(more)
+        new_oldest = int(more[-1][0])
+        if new_oldest >= oldest:
+            break
+        oldest = new_oldest
+        if len(more) < 100:
+            break
+    cols = ["ts", "open", "high", "low", "close", "vol", "volccy", "volq", "confirm"]
+    recs = []
+    for r in allr:
+        r = list(r) + [None] * (9 - len(r))
+        recs.append(r[:9])
+    df = pd.DataFrame(recs, columns=cols)
+    for c in cols:
+        df[c] = pd.to_numeric(df[c], errors="coerce")
+    df["confirm"] = df["confirm"].fillna(1)
+    df = df.dropna(subset=["ts", "close"]).drop_duplicates("ts").sort_values("ts").reset_index(drop=True)
+    df = df[df["close"] > 0].reset_index(drop=True)
+    df["volq"] = df["volq"].where(df["volq"].notna(), df["close"] * df["vol"])
+    df["date"] = pd.to_datetime(df["ts"], unit="ms", utc=True)
+    return df.tail(n).reset_index(drop=True)
+
+
+def fetch_perp(inst: str) -> Tuple[Optional[float], Optional[float]]:
+    """Perp funding rate (8h) ve open interest (USD). Perp yoksa (None, None)."""
+    parts = inst.split("-")
+    swap = f"{parts[0]}-{parts[1]}-SWAP" if len(parts) >= 2 else None
+    if not swap:
+        return None, None
+    funding, oi_usd = None, None
+    fr = okx_get("/api/v5/public/funding-rate", {"instId": swap})
+    if fr:
+        funding = num(fr[0].get("fundingRate"))
+    if funding is not None:
+        time.sleep(REQUEST_DELAY_SEC)
+        oi = okx_get("/api/v5/public/open-interest", {"instType": "SWAP", "instId": swap})
+        if oi:
+            oi_usd = num(oi[0].get("oiUsd"))
+    return funding, oi_usd
+
+
+def _tail(a, k, min_frac=0.6):
+    return a[-k:] if len(a) > 0 and len(a) >= int(np.ceil(k * min_frac)) else None
+
+
+def metrics_from_candles(conf: pd.DataFrame, price: float, bid: Optional[float] = None, ask: Optional[float] = None) -> Dict[str, Any]:
+    """Pure function: confirmed daily candles + live price -> derived [D] metrics."""
+    c = conf["close"].to_numpy(float)
+    h = conf["high"].to_numpy(float)
+    vb = conf["vol"].to_numpy(float)
+    vq = conf["volq"].to_numpy(float)
+    n = len(c)
+    m: Dict[str, Any] = {"hist_days": n}
+    lr = np.diff(np.log(c)) if n >= 2 else np.array([])
+    rets = c[1:] / c[:-1] - 1 if n >= 2 else np.array([])
+
+    def ret_k(k):
+        return price / c[-k] - 1 if n >= k else None
+
+    m["ret30"], m["ret90"], m["ret365"] = ret_k(30), ret_k(90), ret_k(365)
+
+    def vol_k(k):
+        t = _tail(lr, k)
+        return float(np.std(t, ddof=1) * np.sqrt(365)) if t is not None and len(t) >= 15 else None
+
+    m["vol30"], m["vol90"], m["vol365"] = vol_k(30), vol_k(90), vol_k(365)
+    m["sharpe"] = m["sortino"] = None
+    t = _tail(lr, 365)
+    if t is not None and len(t) >= 100:
+        sd = float(np.std(t, ddof=1))
+        if sd > 1e-12:
+            m["sharpe"] = float(np.mean(t) / sd * np.sqrt(365))
+        dd = float(np.sqrt(np.mean(np.minimum(t, 0) ** 2)))
+        if dd > 1e-12:
+            m["sortino"] = float(np.mean(t) / dd * np.sqrt(365))
+    w = c[-365:]
+    m["maxdd"] = None
+    if len(w) >= 60:
+        cs = np.append(w, price)
+        m["maxdd"] = float(np.max(1 - cs / np.maximum.accumulate(cs)))
+    m["hi365"], m["dd_high"] = None, None
+    if n >= 30:
+        hi = float(max(np.nanmax(h[-365:]), price))
+        m["hi365"], m["dd_high"] = hi, 1 - price / hi
+    m["sma50"] = float(np.mean(c[-50:])) if n >= 50 else None
+    m["sma200"] = float(np.mean(c[-200:])) if n >= 200 else None
+    m["vwap365"] = None
+    if n >= 120:
+        sb, sq = np.nansum(vb[-365:]), np.nansum(vq[-365:])
+        if sb > 0 and sq > 0:
+            m["vwap365"] = float(sq / sb)
+    m["trend_fair"] = m["trend_g"] = m["trend_z"] = m["trend_sigma"] = None
+    if n >= 120:
+        mm = min(n, 500)
+        y, x = np.log(c[-mm:]), np.arange(mm, dtype=float)
+        slope, icpt = np.polyfit(x, y, 1)
+        sigma = float(np.std(y - (icpt + slope * x), ddof=2))
+        fit_now = icpt + slope * mm
+        m["trend_fair"] = float(np.exp(fit_now))
+        m["trend_g"] = float(np.exp(slope * 365) - 1)
+        m["trend_sigma"] = sigma
+        if sigma > 1e-9:
+            m["trend_z"] = float((np.log(price) - fit_now) / sigma)
+    q30, q90 = _tail(vq, 30), _tail(vq, 90)
+    m["vq30"] = float(np.nanmean(q30)) if q30 is not None else None
+    m["vq90"] = float(np.nanmean(q90)) if q90 is not None else None
+    m["vol_ratio"] = div(m["vq30"], m["vq90"]) if (m["vq90"] or 0) > 0 else None
+    m["vcv"] = float(np.nanstd(q90) / np.nanmean(q90)) if q90 is not None and np.nanmean(q90) > 0 else None
+    r90 = _tail(rets, 90)
+    m["worst90"] = float(np.min(r90)) if r90 is not None else None
+    m["var95"] = float(-np.percentile(r90, 5)) if r90 is not None else None
+    m["spread_bps"] = None
+    if bid and ask and bid > 0 and ask > 0 and ask >= bid:
+        m["spread_bps"] = (ask - bid) / ((ask + bid) / 2) * 1e4
+    return m
+
+
+def fetch(inst: str, force: bool = False) -> Optional[Dict[str, Any]]:
+    key = f"t_{inst}"
     if not force:
         c = _cget(key)
         if c is not None:
             return c
     try:
-        t = yf.Ticker(symbol)
-        info = t.info or {}
-        fin, bs, cf = t.financials, t.balance_sheet, t.cashflow
-        try:
-            dv = t.dividends
-        except Exception:
-            dv = None
-        price = num(info.get("currentPrice")) or num(info.get("regularMarketPrice"))
-        if price is None:
-            h = t.history(period="5d")
-            price = num(h["Close"].iloc[-1]) if not h.empty else None
+        df = fetch_candles(inst)
+        tk = get_tickers().get(inst)
+        if tk is None:
+            rows = okx_get("/api/v5/market/ticker", {"instId": inst})
+            tk = rows[0] if rows else None
+        funding, oi_usd = fetch_perp(inst) if SETTINGS.get("perp", True) else (None, None)
     except Exception as e:
-        logger.warning("%s fetch failed: %s", symbol, e)
+        logger.warning("%s fetch failed: %s", inst, e)
         return None
-    if price is None or price <= 0:
+    if df is None or df.empty:
+        return None
+    conf = df[df["confirm"] >= 1].reset_index(drop=True)
+    price = num(tk.get("last")) if tk else None
+    if price is None:
+        price = num(df["close"].iloc[-1])
+    if price is None or price <= 0 or len(conf) < 10:
         return None
 
     flags: List[str] = []
-    dfs = {"fin": fin, "bs": bs, "cf": cf}
-    s = {k: [stmt(dfs[src], names, i) for i in range(3)] for k, (names, src) in STMT.items()}
-    s["capex"] = [abs(x) if x is not None else None for x in s["capex"]]
-    s["interest"] = [abs(x) if x is not None else None for x in s["interest"]]
-    for i in range(3):
-        if s["fcf"][i] is None and s["cfo"][i] is not None and s["capex"][i] is not None:
-            s["fcf"][i] = s["cfo"][i] - s["capex"][i]
-        if s["ebitda"][i] is None and s["opinc"][i] is not None and s["da"][i] is not None:
-            s["ebitda"][i] = s["opinc"][i] + s["da"][i]
-    if s["debt"][0] is None:
-        s["debt"][0] = num(info.get("totalDebt"))
-        if s["debt"][0] is not None:
-            flags.append("debt from info (not statement)")
-    if s["cash"][0] is None:
-        s["cash"][0] = num(info.get("totalCash"))
-        if s["cash"][0] is not None:
-            flags.append("cash from info (not statement)")
-
-    # period / currency / unit validation
-    sd = None
-    try:
-        sd = pd.Timestamp(fin.columns[0]).to_pydatetime() if fin is not None and not fin.empty else None
-        for nm, df in (("balance sheet", bs), ("cash flow", cf)):
-            if df is not None and not df.empty and sd is not None and pd.Timestamp(df.columns[0]).to_pydatetime() != sd:
-                flags.append(f"{nm} period != income statement period")
-    except Exception:
-        pass
-    age = (datetime.now() - sd).days if sd else None
-    if age is not None and age > 550:
-        flags.append(f"stale statements ({age} days)")
-    if sd is None:
-        flags.append("no annual statements")
-    fc, cur = info.get("financialCurrency"), info.get("currency")
-    unit_ok = (fc is None) or (cur is None) or (fc == cur)
-    if not unit_ok:
-        flags.append(f"currency mismatch (fin {fc} vs price {cur})")
-    if fc is None:
-        flags.append("financial currency unknown")
-
-    shares = num(info.get("sharesOutstanding")) or s["shares"][0]
-    mcap = num(info.get("marketCap")) or (price * shares if shares else None)
-    if shares and mcap and abs(price * shares / mcap - 1) > 0.35:
-        flags.append("shares x price differs >35% from market cap")
-    eq0, ta0 = s["eq"][0], s["ta"][0]
-    if eq0 is not None and ta0 is not None and eq0 > ta0 * 1.01:
-        flags.append("equity > total assets (suspicious)")
-    if s["rev"][0] and s["ni"][0] is not None and abs(s["ni"][0]) > 1.0 * s["rev"][0] and s["rev"][0] > 0:
-        flags.append("|net income| > revenue (suspicious)")
-
-    bvps = num(info.get("bookValue")) or div(eq0, shares)
-    eps = num(info.get("trailingEps")) or div(s["ni"][0], shares)
-    if eps is not None and shares and s["ni"][0] not in (None, 0) and abs(eps * shares / s["ni"][0] - 1) > 0.5:
-        flags.append("EPS x shares differs >50% from net income")
-
-    # dividends: 0 only if history fetched and empty; None if unavailable
-    dy = None
-    try:
-        if dv is not None:
-            if len(dv) > 0:
-                cutoff = pd.Timestamp.now(tz=dv.index.tz) - pd.Timedelta(days=365)
-                dy = float(dv[dv.index >= cutoff].sum()) / price
-            else:
-                dy = 0.0
-    except Exception:
-        dy = None
-    if dy is None:
-        y = num(info.get("dividendYield"))
-        if y is not None:
-            dy = y / 100 if y > 1 else y
-
-    tax_assumed = False
-    tr = div(s["tax"][0], s["pretax"][0]) if (s["pretax"][0] or 0) > 0 else None
-    if tr is None:
-        tr, tax_assumed = 0.25, True
-    tr = float(np.clip(tr, 0, 0.35))
-
-    net_debt = (s["debt"][0] - s["cash"][0]) if (s["debt"][0] is not None and s["cash"][0] is not None) else None
-    fcf0, int0 = s["fcf"][0], s["interest"][0]
-    fcff = (fcf0 + int0 * (1 - tr)) if (fcf0 is not None and int0 is not None) else None  # unlevered -> net debt bridge
-    oe, oe_parts = None, None
-    ni0, da0, cx0, wc0 = s["ni"][0], s["da"][0], s["capex"][0], s["dwc"][0]
-    if None not in (ni0, da0, cx0, wc0):
-        maint = min(cx0, da0)  # [D] estimate: maintenance capex ~ min(total capex, D&A)
-        oe = ni0 + da0 - maint + wc0
-        oe_parts = dict(ni=ni0, da=da0, capex_total=cx0, maint_est=maint, dwc=wc0)
-    ev = (mcap + net_debt) if (mcap and net_debt is not None) else num(info.get("enterpriseValue"))
-    ebitda0 = s["ebitda"][0]
-    industry = info.get("industry") or "Unknown"
-    seg = segment_of(industry, symbol)
-    roes = [div(s["ni"][i], s["eq"][i]) for i in range(3) if (s["eq"][i] or 0) > 0]
-    roes = [r for r in roes if r is not None]
-    ir = num(info.get("returnOnEquity"))
-    if ir is not None:
-        roes.append(ir)
-    sust_roe = float(np.clip(np.mean(roes), -1, 1.5)) if roes else None
-
+    notes: List[str] = []
+    mt = metrics_from_candles(conf, price, num(tk.get("bidPx")) if tk else None, num(tk.get("askPx")) if tk else None)
+    n = mt["hist_days"]
+    if tk is None:
+        flags.append("ticker missing (price from last candle)")
+    if n < 200:
+        flags.append(f"short history ({n} days; SMA200 unavailable)")
+    last_ts = int(conf["ts"].iloc[-1])
+    last_dt = pd.to_datetime(last_ts, unit="ms", utc=True)
+    age_h = (datetime.now(timezone.utc) - (last_dt + pd.Timedelta(days=1))).total_seconds() / 3600
+    if age_h > 48:
+        flags.append(f"stale candles ({age_h:.0f} h)")
+    first_ts = int(conf["ts"].iloc[0])
+    gaps = int(round((last_ts - first_ts) / 86_400_000)) + 1 - n
+    if gaps > 3:
+        flags.append(f"{gaps} missing daily candles")
+    zero_days = int((conf["volq"].to_numpy(float)[-90:] == 0).sum())
+    if zero_days > 3:
+        flags.append(f"{zero_days} zero-volume days (last 90)")
+    if abs(price / float(conf["close"].iloc[-1]) - 1) > 0.30:
+        flags.append("live price deviates >30% from last close")
+    if funding is None:
+        notes.append("no perp (funding/OI) data")
+
+    base = inst.split("-")[0]
+    open24 = num(tk.get("open24h")) if tk else None
+    vol24 = num(tk.get("volCcy24h")) if tk else None
     d = {
-        "sym": symbol, "name": info.get("shortName") or symbol, "price": price, "mcap": mcap,
-        "shares": shares, "sector": info.get("sector") or "Unknown", "industry": industry, "seg": seg,
-        "bvps": bvps, "eps": eps, "dy": dy, "s": s, "flags": flags, "unit_ok": unit_ok, "stmt_date": sd, "age": age,
-        "tax_rate": tr, "tax_assumed": tax_assumed, "net_debt": net_debt, "fcff": fcff, "fcf0": fcf0, "oe": oe,
-        "oe_parts": oe_parts, "ev": ev, "sust_roe": sust_roe,
-        "pe": price / eps if eps and eps > 0 else None,
-        "fpe": num(info.get("forwardPE")) if (num(info.get("forwardPE")) or 0) > 0 else None,
-        "pb": price / bvps if bvps and bvps > 0 else None,
-        "ps": div(mcap, s["rev"][0]) if (s["rev"][0] or 0) > 0 else None,
-        "ev_ebitda": div(ev, ebitda0) if (ebitda0 or 0) > 0 and ev else None,
-        "ev_fcf": div(ev, fcf0) if (fcf0 or 0) > 0 and ev else None,
-        "fcf_yield": div(fcf0, mcap), "earn_yield": div(eps, price), "fetched": datetime.now().isoformat(),
+        "sym": inst, "name": base, "base": base, "price": price, "seg": CATEGORY.get(base, "Other"),
+        "sector": tier_of(mt["vq30"] if mt["vq30"] is not None else vol24), "vol24": vol24,
+        "chg24": (price / open24 - 1) if open24 else None, "funding": funding, "oi_usd": oi_usd,
+        "flags": flags, "notes": notes, "unit_ok": True, "last_dt": last_dt, "age_h": age_h,
+        "p_vwap": div(price, mt["vwap365"]), "p_sma200": div(price, mt["sma200"]),
+        "p_trend": div(price, mt["trend_fair"]), "p_high": div(price, mt["hi365"]),
+        "hist": conf[["date", "close"]].tail(365).reset_index(drop=True), "fetched": datetime.now().isoformat(),
+        **mt,
     }
     _cset(key, d)
     return d
@@ -337,14 +446,14 @@ def cached_ds() -> List[Dict[str, Any]]:
     return [v for k, (ts, v) in _cache.items() if k.startswith("t_") and v is not None]
 
 
-MULTS = ["pe", "fpe", "pb", "ev_ebitda", "ev_fcf", "ps", "fcf_yield", "earn_yield"]
-POS_ONLY = {"pe", "fpe", "pb", "ev_ebitda", "ev_fcf", "ps"}
+MULTS = ["p_vwap", "p_sma200", "p_trend", "p_high", "ret90", "vol90", "sharpe"]
+POS_ONLY = {"p_vwap", "p_sma200", "p_trend", "p_high"}
 
 
-def build_medians(ds) -> Dict[Tuple[str, str], Dict[str, Tuple[Optional[float], int]]]:
-    groups: Dict[Tuple[str, str], list] = {}
+def build_medians(ds) -> Dict[str, Dict[str, Tuple[Optional[float], int]]]:
+    groups: Dict[str, list] = {}
     for d in ds:
-        groups.setdefault((d["seg"], d["sector"]), []).append(d)
+        groups.setdefault(d["seg"], []).append(d)
     med = {}
     for k, g in groups.items():
         m = {}
@@ -356,23 +465,19 @@ def build_medians(ds) -> Dict[Tuple[str, str], Dict[str, Tuple[Optional[float],
 
 
 # ============================================================================
-# VALUATION ENGINE
+# VALUATION ENGINE  (fiyat-bazlı fair value; fundamental yoktur)
 # ============================================================================
 
-def dcf_value(base, g0, wacc, tg, shares, net_debt, years=5) -> Optional[Dict[str, float]]:
-    """5-year explicit DCF, growth fades linearly g0 -> tg. Returns None if inputs insufficient."""
-    if None in (base, g0, wacc, tg, shares, net_debt) or base <= 0 or shares <= 0 or wacc <= tg:
+def dep_value(anchor, g0, wacc, tg, years=5) -> Optional[Dict[str, float]]:
+    """Discounted Expected Price: anchor fiyatı 5 yıl boyunca g0 -> tg doğrusal sönen drift ile büyütülür,
+    gereken getiri (wacc) ile bugüne iskonto edilir. DCF'in nakit akışsız karşılığıdır."""
+    if None in (anchor, g0, wacc, tg) or anchor <= 0 or wacc <= tg:
         return None
-    flows, f = [], base
+    p = anchor
     for t in range(1, years + 1):
         g = g0 + (tg - g0) * (t - 1) / (years - 1)
-        f *= 1 + g
-        flows.append(f)
-    pv = sum(fl / (1 + wacc) ** (i + 1) for i, fl in enumerate(flows))
-    pvtv = flows[-1] * (1 + tg) / (wacc - tg) / (1 + wacc) ** years
-    ev = pv + pvtv
-    eq = ev - net_debt
-    return {"ev": ev, "equity": eq, "per_share": eq / shares, "tv_share": pvtv / ev if ev else 0.0}
+        p *= 1 + g
+    return {"p_future": p, "per_unit": p / (1 + wacc) ** years}
 
 
 def assumptions(P, rg=None, rw=None):
@@ -382,75 +487,66 @@ def assumptions(P, rg=None, rw=None):
     return (1 + rg) * (1 + i * P["pt"]) - 1, (1 + rw) * (1 + i) - 1, (1 + P["rtg"]) * (1 + i) - 1  # g0, wacc, tg (nominal)
 
 
-def dcf_try(base, g0, wacc, tg, shares, nd, ok):
-    if not ok:
-        return None, "currency/unit mismatch"
-    if base is None:
-        return None, "essential inputs missing"
-    if base <= 0:
-        return None, "non-positive base cash flow"
-    if not shares or shares <= 0:
-        return None, "shares unavailable"
-    if nd is None:
-        return None, "net debt unavailable"
+def anchor_of(d) -> Optional[float]:
+    v = [x for x in (d.get("trend_fair"), d.get("vwap365"), d.get("sma200")) if x is not None and x > 0]
+    return float(np.median(v)) if len(v) >= 2 else None
+
+
+def dep_try(anchor, g0, wacc, tg):
+    if anchor is None:
+        return None, "needs >=2 price anchors (trend / VWAP / SMA200)"
+    if anchor <= 0:
+        return None, "non-positive anchor"
     if wacc <= tg:
-        return None, "discount rate <= terminal growth"
-    r = dcf_value(base, g0, wacc, tg, shares, nd)
-    if r is None or r["per_share"] <= 0:
-        return None, "equity value <= 0"
-    return r["per_share"], f"TV = {r['tv_share'] * 100:.0f}% of EV"
+        return None, "discount rate <= terminal drift"
+    r = dep_value(anchor, g0, wacc, tg)
+    if r is None or r["per_unit"] <= 0:
+        return None, "value <= 0"
+    return r["per_unit"], f"anchor {fpx(anchor)} → {fpx(r['p_future'])} (5y) → discounted"
 
 
 def relative_value(d, med) -> Tuple[Optional[float], str]:
-    m = med.get((d["seg"], d["sector"]))
-    if not m or not d["unit_ok"]:
-        return None, "no peer group / unit mismatch"
-    seg, vals = d["seg"], []
-    if m["pb"][0] and d["bvps"] and d["bvps"] > 0:
-        vals.append(m["pb"][0] * d["bvps"])
-    if seg != "REIT" and m["pe"][0] and d["eps"] and d["eps"] > 0:
-        vals.append(m["pe"][0] * d["eps"])
-    if seg == "Industrial" and m["ev_ebitda"][0] and (d["s"]["ebitda"][0] or 0) > 0 and d["net_debt"] is not None and d["shares"]:
-        vals.append((m["ev_ebitda"][0] * d["s"]["ebitda"][0] - d["net_debt"]) / d["shares"])
+    m = med.get(d["seg"])
+    if not m:
+        return None, "no peer group"
+    vals = []
+    if m["p_vwap"][0] and d.get("vwap365"):
+        vals.append(m["p_vwap"][0] * d["vwap365"])
+    if m["p_sma200"][0] and d.get("sma200"):
+        vals.append(m["p_sma200"][0] * d["sma200"])
+    if m["p_trend"][0] and d.get("trend_fair"):
+        vals.append(m["p_trend"][0] * d["trend_fair"])
     vals = [v for v in vals if v > 0]
     if not vals:
         return None, f"<{MIN_PEERS} valid peers"
-    return float(np.mean(vals)), f"{len(vals)} sector-median multiple(s)"
+    return float(np.mean(vals)), f"{len(vals)} category-median multiple(s)"
 
 
 def intrinsic(d, P, med, rg=None, rw=None):
     g0, wacc, tg = assumptions(P, rg, rw)
     m: Dict[str, Tuple[Optional[float], str]] = {}
-    seg, bv = d["seg"], d["bvps"]
-    if seg in ("Bank", "Insurance"):
-        roe = d["sust_roe"]
-        if d["unit_ok"] and roe is not None and bv and bv > 0 and wacc > tg:
-            m["Justified P/B"] = (max((roe - tg) / (wacc - tg), 0) * bv, f"sust. ROE {fp(roe)}, COE {fp(wacc)}, g {fp(tg)}")
-        else:
-            m["Justified P/B"] = (None, "ROE/book value unavailable")
-        m["DCF"] = (None, "not applied to banks/insurers")
-    elif seg == "REIT":
-        m["NAV proxy (book)"] = ((bv, "book value; appraised NAV not in Yahoo") if (d["unit_ok"] and bv and bv > 0) else (None, "book value unavailable"))
-    else:
-        m["DCF"] = dcf_try(d["fcff"], g0, wacc, tg, d["shares"], d["net_debt"], d["unit_ok"])
-        m["Owner Earnings"] = dcf_try(d["oe"], g0, wacc, tg, d["shares"], 0.0, d["unit_ok"])  # equity CF: no debt bridge
+    tf = d.get("trend_fair")
+    m["Log-Trend Regression"] = ((tf, f"trend {fp(d.get('trend_g'))}/yıl, z={fm(d.get('trend_z'))}") if tf else (None, "needs >=120 days of candles"))
+    vw = d.get("vwap365")
+    m["VWAP 365D"] = ((vw, "hacim-ağırlıklı maliyet bazı vekili") if vw else (None, "needs >=120 days"))
+    s2 = d.get("sma200")
+    m["SMA 200D"] = ((s2, "200 günlük ortalama") if s2 else (None, "needs >=200 days"))
+    m["Discounted Expected Price"] = dep_try(anchor_of(d), g0, wacc, tg)
     m["Relative"] = relative_value(d, med)
     vals = [v for v, _ in m.values() if v is not None and v > 0]
     return m, (float(np.median(vals)) if vals else None)
 
 
 def reverse_dcf(d, P):
-    if d["seg"] in ("Bank", "Insurance"):
-        return None, "FCF-based reverse DCF not applicable to banks/insurers"
-    base, shares, nd = d["fcff"], d["shares"], d["net_debt"]
-    if not d["unit_ok"] or base is None or base <= 0 or not shares or nd is None:
-        return None, "essential inputs missing or FCFF <= 0"
+    base = anchor_of(d)
+    if base is None or base <= 0:
+        return None, "anchor unavailable (needs >=2 of trend / VWAP / SMA200)"
     _, wacc0, tg = assumptions(P)
 
     def solve(wacc):
         if wacc <= tg:
             return None
-        f = lambda g: dcf_value(base, g, wacc, tg, shares, nd)["per_share"]
+        f = lambda g: dep_value(base, g, wacc, tg)["per_unit"]
         lo, hi = -0.9, 3.0
         if not (f(lo) <= d["price"] <= f(hi)):
             return None
@@ -464,7 +560,7 @@ def reverse_dcf(d, P):
         rw = P["rw"] + dw
         w = (1 + rw) * (1 + P["infl"]) - 1
         g = solve(w)
-        rows.append({"Real discount rate": fp(rw), "Nominal WACC": fp(w), "Implied FCF growth (nominal, yr1)": fp(g),
+        rows.append({"Real discount rate": fp(rw), "Nominal discount rate": fp(w), "Implied drift (nominal, yr1)": fp(g),
                      "Implied (real)": fp(real_ret(g, P["infl"]))})
     return rows, "ok"
 
@@ -482,10 +578,8 @@ def scenarios(d, P, med, probs):
         return out, None
     pw = sum(o["Prob"] * o["Target"] for o in out)
     nom = pw / d["price"] - 1
-    dy = d["dy"] or 0.0
-    tot = nom + dy
-    return out, dict(pw=pw, nominal=nom, total=tot, real=real_ret(tot, P["infl"]), real_price=real_ret(nom, P["infl"]),
-                     dy_known=d["dy"] is not None)
+    tot = nom  # spot: temettü/gelir yok
+    return out, dict(pw=pw, nominal=nom, total=tot, real=real_ret(tot, P["infl"]), real_price=real_ret(nom, P["infl"]), dy_known=True)
 
 
 def validate_probs(bear, base):
@@ -496,100 +590,57 @@ def validate_probs(bear, base):
 
 
 # ============================================================================
-# QUALITY, PIOTROSKI, RISK
+# QUALITY, MARKET HEALTH, RISK
 # ============================================================================
 
-def cv(series):
-    v = [x for x in series if x is not None]
-    if len(v) < 3 or np.mean(v) <= 0:
-        return None
-    return float(np.std(v) / np.mean(v))
-
-
 def quality(d):
-    s, q = d["s"], {}
-    ni0, eq0, ta0, rev0 = s["ni"][0], s["eq"][0], s["ta"][0], s["rev"][0]
-    q["roe"] = div(ni0, eq0) if (eq0 or 0) > 0 else None
-    q["roa"] = div(ni0, ta0)
-    ic = None
-    if None not in (eq0, s["debt"][0], s["cash"][0]):
-        ic = eq0 + s["debt"][0] - s["cash"][0]
-    q["roic"] = div(s["opinc"][0] * (1 - d["tax_rate"]), ic) if (s["opinc"][0] is not None and ic and ic > 0) else None
-    q["gm"] = div(s["gp"][0], rev0)
-    q["opm"] = div(s["opinc"][0], rev0)
-    q["npm"] = div(ni0, rev0)
-    q["de"] = div(s["debt"][0], eq0) * 100 if (eq0 or 0) > 0 and s["debt"][0] is not None else None
-    e0 = s["ebitda"][0]
-    q["nd_ebitda"] = div(d["net_debt"], e0) if (e0 or 0) > 0 and d["net_debt"] is not None else None
-    q["cr"] = div(s["ca"][0], s["cl"][0])
-    q["icov"] = div(s["opinc"][0], s["interest"][0]) if (s["interest"][0] or 0) > 0 else None
-    q["fcf_conv"] = div(s["fcf"][0], ni0) if (ni0 or 0) > 0 else None
-    q["fcf_cv"] = cv(s["fcf"])
-    q["ni_cv"] = cv(s["ni"])
-    q["rev_g"] = growth(rev0, s["rev"][1])
-    q["ni_g"] = growth(ni0, s["ni"][1])
-    q["eq_ta"] = div(eq0, ta0)
+    q = {k: d.get(k) for k in ("ret30", "ret90", "ret365", "vol30", "vol90", "vol365", "sharpe", "sortino", "maxdd", "dd_high",
+                               "trend_z", "spread_bps", "vq30", "vq90", "vol_ratio", "vcv", "worst90", "var95", "hist_days")}
+    q["sma_gap"] = div(d.get("sma50"), d.get("sma200"))
+    q["sma_gap"] = None if q["sma_gap"] is None else q["sma_gap"] - 1
     return q
 
 
-def piotroski(d):
-    s = d["s"]
-
+def market_health(d):
+    """9 ikili bileşenli piyasa sağlığı skoru (Piotroski benzeri). Hesaplanamayan bileşen N/A."""
     def cmp(a, b, op):
         return None if a is None or b is None else op(a, b)
 
-    roa = [div(s["ni"][i], s["ta"][i]) for i in (0, 1)]
-    cr = [div(s["ca"][i], s["cl"][i]) for i in (0, 1)]
-    lev = [div(s["ltd"][i] if s["ltd"][i] is not None else s["debt"][i], s["ta"][i]) for i in (0, 1)]
-    gm = [div(s["gp"][i], s["rev"][i]) for i in (0, 1)]
-    at = [div(s["rev"][i], s["ta"][i]) for i in (0, 1)]
+    fr = d.get("funding")
     comps = [
-        ("1 Net income > 0", cmp(s["ni"][0], 0, lambda a, b: a > b)),
-        ("2 CFO > 0", cmp(s["cfo"][0], 0, lambda a, b: a > b)),
-        ("3 ROA improved", cmp(roa[0], roa[1], lambda a, b: a > b)),
-        ("4 CFO > net income", cmp(s["cfo"][0], s["ni"][0], lambda a, b: a > b)),
-        ("5 Leverage decreased", cmp(lev[0], lev[1], lambda a, b: a < b)),
-        ("6 Current ratio improved", cmp(cr[0], cr[1], lambda a, b: a > b)),
-        ("7 No share dilution", cmp(s["shares"][0], s["shares"][1], lambda a, b: a <= b * 1.005)),
-        ("8 Gross margin improved", cmp(gm[0], gm[1], lambda a, b: a > b)),
-        ("9 Asset turnover improved", cmp(at[0], at[1], lambda a, b: a > b)),
+        ("1 Price > SMA200", cmp(d.get("price"), d.get("sma200"), lambda a, b: a > b)),
+        ("2 SMA50 > SMA200", cmp(d.get("sma50"), d.get("sma200"), lambda a, b: a > b)),
+        ("3 90d return > 0", cmp(d.get("ret90"), 0, lambda a, b: a > b)),
+        ("4 Volatility falling (30d < 90d)", cmp(d.get("vol30"), d.get("vol90"), lambda a, b: a < b)),
+        ("5 Volume not shrinking (30d >= 90d avg)", cmp(d.get("vq30"), d.get("vq90"), lambda a, b: a >= b)),
+        ("6 Drawdown from 1Y high < 40%", cmp(d.get("dd_high"), 0.40, lambda a, b: a < b)),
+        ("7 Sharpe (1Y) > 0", cmp(d.get("sharpe"), 0, lambda a, b: a > b)),
+        ("8 Spread < 10 bps", cmp(d.get("spread_bps"), 10, lambda a, b: a < b)),
+        ("9 Funding not crowded (|f| < 0.03%/8h)", None if fr is None else abs(fr) < 0.0003),
     ]
     n = sum(1 for _, v in comps if v is not None)
     return sum(1 for _, v in comps if v), n, comps
 
 
 def risk_engine(d, q, cov):
-    s, bank = d["s"], d["seg"] in ("Bank", "Insurance")
-    ni0, ni1 = s["ni"][0], s["ni"][1]
     fl = []
 
     def add(name, w, cond, detail):
         fl.append((name, w, None if cond is None else ("TRIGGERED" if cond else "OK"), detail))
 
-    add("Financial distress", 12, anyc(None if s["eq"][0] is None else s["eq"][0] <= 0,
-                                       None if q["icov"] is None else q["icov"] < 1.5,
-                                       None if (ni0 is None or s["cfo"][0] is None) else (ni0 < 0 and s["cfo"][0] < 0)),
-        "equity<=0, interest cover<1.5, or NI<0 & CFO<0")
-    lev = anyc(None if q["eq_ta"] is None else q["eq_ta"] < 0.06) if bank else anyc(
-        None if q["nd_ebitda"] is None else q["nd_ebitda"] > 4, None if q["de"] is None else q["de"] > 200)
-    add("Leverage", 12, lev, "bank: equity/assets<6%; else ND/EBITDA>4 or D/E>200%")
-    add("Liquidity", 10, None if bank else (None if q["cr"] is None else q["cr"] < 1), "current ratio < 1")
-    add("Negative FCF", 10, None if bank else (None if s["fcf"][0] is None else s["fcf"][0] < 0), "FCF < 0")
-    ed = None
-    if ni0 is not None and ni1 is not None:
-        ed = ni0 < 0 or (ni1 > 0 and ni0 < 0.8 * ni1)
-    add("Earnings deterioration", 10, ed, "NI < 0 or down >20% y/y")
-    md = None
-    if not bank and q["opm"] is not None and s["opinc"][1] is not None and (s["rev"][1] or 0) > 0:
-        md = q["opm"] < s["opinc"][1] / s["rev"][1] - 0.02
-    add("Margin deterioration", 8, md, "operating margin down >2 pts")
-    dv = None if bank or ni0 is None or s["cfo"][0] is None or ni0 <= 0 else s["cfo"][0] < 0.5 * ni0
-    add("CFO vs NI divergence", 10, dv, "CFO < 50% of positive NI")
-    dil = cmp_g = growth(s["shares"][0], s["shares"][1])
-    add("Dilution", 8, None if dil is None else dil > 0.03, "share count +3% y/y")
-    ev = anyc(None if d["pe"] is None and d["eps"] is None else (d["eps"] is not None and d["eps"] <= 0) or (d["pe"] is not None and d["pe"] > 40),
-              None if d["pb"] is None else d["pb"] > 6)
-    add("Extreme valuation", 10, ev, "P/E>40, loss-making, or P/B>6")
+    price, s2, fr = d.get("price"), d.get("sma200"), d.get("funding")
+    add("Extreme volatility", 12, None if q["vol90"] is None else q["vol90"] > 1.2, "90d annualized vol > 120%")
+    add("Deep drawdown", 12, None if q["dd_high"] is None else q["dd_high"] > 0.5, "price >50% below 1Y high")
+    add("Downtrend", 10, None if s2 is None else price < s2, "price < SMA200")
+    add("Thin liquidity", 10, None if q["vq30"] is None else q["vq30"] < 5e6, "30d avg daily volume < 5M USDT")
+    add("Wide spread", 8, None if q["spread_bps"] is None else q["spread_bps"] > 15, "bid/ask spread > 15 bps")
+    add("Volume collapse", 8, None if q["vol_ratio"] is None else q["vol_ratio"] < 0.5, "30d avg volume < 50% of 90d avg")
+    add("Crash day", 8, None if q["worst90"] is None else q["worst90"] < -0.15, "worst daily return (90d) < -15%")
+    add("Tail risk (VaR95)", 8, None if q["var95"] is None else q["var95"] > 0.08, "daily 95% VaR (90d) > 8%")
+    add("Overextension", 8, anyc(None if q["trend_z"] is None else q["trend_z"] > 2,
+                                 None if d.get("p_sma200") is None else d["p_sma200"] > 1.6),
+        "trend z-score > 2 or price > 1.6x SMA200")
+    add("Funding crowding", 6, None if fr is None else abs(fr) > 0.0005, "|funding| > 0.05% per 8h")
     add("Data reliability", 10, cov < 0.7 or bool(d["flags"]), f"coverage<70% or integrity flags ({len(d['flags'])})")
     ev_w = sum(w for _, w, st, _ in fl if st is not None)
     score = None if ev_w == 0 else 100 * sum(w for _, w, st, _ in fl if st == "TRIGGERED") / ev_w
@@ -600,70 +651,49 @@ def risk_engine(d, q, cov):
 # SCORING & ANALYSIS
 # ============================================================================
 
-WEIGHTS = {"Industrial": (.35, .30, .20, .15), "Bank": (.40, .35, .10, .15),
-           "Insurance": (.40, .30, .15, .15), "REIT": (.45, .20, .20, .15)}
+WEIGHTS = {"Majors": (.30, .25, .25, .20), "Meme": (.25, .15, .20, .40)}
+DEFAULT_W = (.30, .25, .20, .25)
 
 
 def coverage(d):
-    s, seg = d["s"], d["seg"]
-    f = [d["price"], d["mcap"], d["shares"], d["pb"], d["pe"], s["ni"][0], s["eq"][0], s["ta"][0], d["bvps"]]
-    if seg not in ("Bank", "Insurance"):
-        f += [s["rev"][0], s["cfo"][0], s["debt"][0], s["cash"][0], d["fcff"], s["ebitda"][0], d["oe"]]
+    f = [d.get("price"), d.get("vq30"), d.get("spread_bps"), d.get("sma50"), d.get("sma200"), d.get("vwap365"),
+         d.get("trend_fair"), d.get("vol90"), d.get("sharpe"), d.get("maxdd"), d.get("ret90"), d.get("ret365")]
     return sum(x is not None for x in f) / len(f)
 
 
 def analyze(d, P, med, probs=(0.25, 0.5, 0.25)):
     A: Dict[str, Any] = {"d": d}
-    infl, seg = P["infl"], d["seg"]
+    infl = P["infl"]
     q = quality(d)
     A["q"] = q
     A["methods"], A["iv"] = intrinsic(d, P, med)
     A["mos"] = (A["iv"] - d["price"]) / A["iv"] if A["iv"] else None
     rv, A["rel_note"] = relative_value(d, med)
     A["rel_mos"] = (rv - d["price"]) / rv if rv else None
-    A["pio"] = piotroski(d)
+    A["pio"] = market_health(d)
     A["cov"] = coverage(d)
     A["risk"], A["flags"] = risk_engine(d, q, A["cov"])
-    bank = seg in ("Bank", "Insurance")
-    rroe, rroic = real_ret(q["roe"], infl), real_ret(q["roic"], infl)
-    rrev, rni = real_ret(q["rev_g"], infl), real_ret(q["ni_g"], infl)
-    pe_s = (0.0 if d["eps"] <= 0 else lin(d["pe"], 25, 4)) if d["eps"] is not None else None
-    pb_s = lin(d["pb"], 4, 0.5) if d["pb"] else (0.0 if d["bvps"] is not None and d["bvps"] <= 0 else None)
-    vi = [(lin(A["mos"], -0.3, 0.5), 4), (lin(A["rel_mos"], -0.3, 0.5), 2)]
-    if bank:
-        vi += [(pe_s, 2), (pb_s, 3), (lin(d["dy"], 0, 0.08), 1)]
-    elif seg == "REIT":
-        vi += [(lin(d["pb"], 1.5, 0.4), 3), (pe_s, 1)]
-    else:
-        vi += [(pe_s, 1), (pb_s, 1), (lin(d["ev_ebitda"], 15, 3), 1), (lin(d["fcf_yield"], -0.02, 0.12), 1),
-               (lin(d["earn_yield"], 0, 0.25), 1)]
-    if bank:
-        qi = [(lin(rroe, -0.1, 0.2), 4), (lin(q["roa"], 0, 0.03), 2), (lin(q["ni_cv"], 2, 0.3), 2),
-              (lin(d["dy"], 0, 0.08), 1), (lin(rni, -0.2, 0.3), 1)]
-    else:
-        qi = [(lin(rroe, -0.1, 0.2), 3), (lin(rroic, -0.05, 0.15), 3), (lin(q["opm"], 0.02, 0.25), 2),
-              (lin(q["fcf_conv"], 0, 1.2), 2), (lin(q["fcf_cv"], 2, 0.3), 1), (lin(rrev, -0.1, 0.2), 1), (lin(rni, -0.2, 0.3), 1)]
+    rret365, rret90 = real_ret(q["ret365"], infl), real_ret(q["ret90"], infl)
+    liq = math.log10(q["vq30"]) if q["vq30"] and q["vq30"] > 0 else None
+
+    vi = [(lin(A["mos"], -0.3, 0.5), 4), (lin(A["rel_mos"], -0.3, 0.5), 2), (lin(d.get("trend_z"), 2, -2), 2),
+          (lin(d.get("p_sma200"), 1.6, 0.8), 1), (lin(q["dd_high"], 0.0, 0.6), 1)]
+    qi = [(lin(rret365, -0.5, 1.5), 3), (lin(q["sharpe"], -0.5, 2.0), 3), (lin(q["sortino"], -0.5, 3.0), 2),
+          (lin(q["maxdd"], 0.8, 0.25), 2), (lin(rret90, -0.3, 0.5), 1), (lin(q["vcv"], 2, 0.3), 1)]
     sc, n, _ = A["pio"]
-    e0 = d["s"]["ebitda"][0]
-    if bank:
-        si = [(lin(q["eq_ta"], 0.04, 0.12), 4), (lin(q["roa"], 0, 0.02), 1)]
-    else:
-        nde = 0.0 if (e0 is not None and e0 <= 0 and (d["net_debt"] or 0) > 0) else lin(q["nd_ebitda"], 5, 0)
-        if q["nd_ebitda"] is None and d["net_debt"] is not None and d["net_debt"] <= 0 and (e0 or 0) > 0:
-            nde = 100.0  # net cash
-        si = [(nde, 3), (lin(q["cr"], 0.8, 2.0), 2), (lin(q["icov"], 1, 8), 2), (lin(q["de"], 250, 30), 2),
-              (lin(sc / n, 0.3, 0.8) if n >= 5 else None, 2)]
+    si = [(lin(liq, 6, 9), 3), (lin(q["spread_bps"], 30, 2), 2), (lin(q["hist_days"], 90, 500), 2),
+          (lin(q["vol90"], 1.5, 0.4), 2), (lin(sc / n, 0.3, 0.8) if n >= 5 else None, 2)]
     A["val"], A["val_cov"] = wavg(vi)
     A["qual"], A["qual_cov"] = wavg(qi)
     A["str"], A["str_cov"] = wavg(si)
-    w = WEIGHTS[seg]
+    w = WEIGHTS.get(d["seg"], DEFAULT_W)
     comps = [A["val"], A["qual"], A["str"], None if A["risk"] is None else 100 - A["risk"]]
     if A["val"] is None or A["qual"] is None:
         A["composite"] = None
     else:
         av = [(c, wt) for c, wt in zip(comps, w) if c is not None]
         A["composite"] = sum(c * wt for c, wt in av) / sum(wt for _, wt in av) * min(1.0, A["cov"] / 0.7)
-    sev = (not d["unit_ok"]) or any("stale" in f or "period" in f for f in d["flags"])
+    sev = any("stale" in f or "missing daily" in f or "deviates" in f for f in d["flags"])
     lvl = 2 if A["cov"] >= 0.85 else 1 if A["cov"] >= 0.65 else 0
     lvl = max(lvl - (1 if sev else 0), 0)
     A["conf"] = ["Low", "Medium", "High"][lvl]
@@ -680,20 +710,20 @@ def get_A(ticker, P, probs=(0.25, 0.5, 0.25)):
     sym = norm_sym(ticker)
     d = fetch(sym)
     if d is None:
-        return None, f"⚠️ {sym} verisi çekilemedi."
+        return None, f"⚠️ {sym or '?'} OKX'ten çekilemedi (parite yok, geçmiş yetersiz ya da ağ hatası)."
     return analyze(d, P, build_medians(cached_ds()), probs), None
 
 
-def price_fig(sym, extra=None):
+def price_fig(d, extra=None):
     try:
-        h = yf.Ticker(norm_sym(sym)).history(period="1y")
-        if h.empty:
+        h = d["hist"]
+        if h is None or h.empty:
             return None
-        f = go.Figure(go.Scatter(x=h.index, y=h["Close"], mode="lines", name="Close"))
+        f = go.Figure(go.Scatter(x=h["date"], y=h["close"], mode="lines", name="Close"))
         for nm, v in (extra or {}).items():
             if v:
                 f.add_hline(y=v, line_dash="dot", annotation_text=nm)
-        f.update_layout(title=f"{sym} — 1Y", template="plotly_white", height=380, margin=dict(l=10, r=10, t=40, b=10))
+        f.update_layout(title=f"{d['sym']} — 1Y (OKX, USDT)", template="plotly_white", height=380, margin=dict(l=10, r=10, t=40, b=10))
         return f
     except Exception:
         return None
@@ -704,25 +734,29 @@ def scan_row(A):
     sc, n, _ = A["pio"]
     e = A["exp"]
     return {
-        "Ticker": d["sym"], "Segment": d["seg"], "Sector": d["sector"], "Price": round(d["price"], 2),
+        "Pair": d["sym"], "Segment": d["seg"], "Tier": d["sector"], "Price": rsig(d["price"]),
         "Composite": None if A["composite"] is None else round(A["composite"], 1),
-        "Intrinsic": None if A["iv"] is None else round(A["iv"], 2),
+        "Fair value": rsig(A["iv"]),
         "MoS %": None if A["mos"] is None else round(A["mos"] * 100, 1),
-        "P/E": None if d["pe"] is None else round(d["pe"], 1), "P/B": None if d["pb"] is None else round(d["pb"], 2),
-        "ROE %": None if q["roe"] is None else round(q["roe"] * 100, 1),
-        "ROIC %": None if q["roic"] is None else round(q["roic"] * 100, 1),
-        "FCF Yield %": None if d["fcf_yield"] is None else round(d["fcf_yield"] * 100, 1),
-        "Piotroski": f"{sc}/{n} (cov {n}/9)" if n else "N/A",
+        "vs VWAP365 %": None if d["p_vwap"] is None else round((d["p_vwap"] - 1) * 100, 1),
+        "Ret 90d %": pct(q["ret90"]), "Vol 90d %": pct(q["vol90"], 0),
+        "Sharpe 1Y": None if q["sharpe"] is None else round(q["sharpe"], 2),
+        "MaxDD 1Y %": pct(q["maxdd"], 0),
+        "Health": f"{sc}/{n} (cov {n}/9)" if n else "N/A",
         "Risk": None if A["risk"] is None else round(A["risk"], 0),
-        "Exp Return % (nom, incl div)": None if not e else round(e["total"] * 100, 1),
+        "Exp Return % (12M)": None if not e else round(e["total"] * 100, 1),
         "Real Exp Return %": None if not e or e["real"] is None else round(e["real"] * 100, 1),
+        "Vol30d avg (M USDT)": None if q["vq30"] is None else round(q["vq30"] / 1e6, 1),
+        "Funding % (8h)": None if d["funding"] is None else round(d["funding"] * 100, 4),
         "Coverage %": round(A["cov"] * 100), "Confidence": A["conf"],
     }
 
 
-def run_scan(force, extra, P, progress):
-    syms = US_UNIVERSE + [norm_sym(x) for x in (extra or "").split(",") if x.strip()]
-    syms = list(dict.fromkeys(syms))
+def run_scan(force, extra, P, progress, n=DEFAULT_UNIVERSE_N):
+    base, src = build_universe(int(n))
+    syms = base + [norm_sym(x) for x in (extra or "").split(",") if x.strip()]
+    syms = [s for s in dict.fromkeys(syms) if s]
+    LAST["universe"] = syms
     ds, failed = [], []
     for i, s in enumerate(syms):
         progress((i + 1) / len(syms), desc=f"Fetching {s}")
@@ -735,7 +769,7 @@ def run_scan(force, extra, P, progress):
     rows = [scan_row(analyze(d, P, med)) for d in ds]
     df = pd.DataFrame(rows)
     LAST["df"], LAST["failed"] = df, failed
-    return df, failed
+    return df, failed, src
 
 
 def apply_filters(seg, minc, minm, sortby, desc):
@@ -749,26 +783,29 @@ def apply_filters(seg, minc, minm, sortby, desc):
     if minm > -100:
         x = x[x["MoS %"].fillna(-1e9) >= minm]
     x = x.sort_values(sortby, ascending=not desc, na_position="last")
-    f = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", prefix="us_v3_")
+    f = tempfile.NamedTemporaryFile(delete=False, suffix=".csv", prefix="okx_v1_")
     x.to_csv(f.name, index=False)
     return x, f.name
 
 
 def md_report(A, P):
     d = A["d"]
-    L = [f"## {d['sym']} — {d['name']}",
-         f"**{d['seg']}** · {d['sector']} / {d['industry']} · Fiyat **{fm(d['price'])} USD** · Mali tablo: "
-         f"{d['stmt_date'].date() if d['stmt_date'] else 'N/A'}",
+    L = [f"## {d['sym']} — OKX Spot",
+         f"**{d['seg']}** · {d['sector']} · Fiyat **{fpx(d['price'])} USDT** · 24s {fp(d['chg24'])} · "
+         f"Son kapanmış mum: {d['last_dt'].date() if d['last_dt'] is not None else 'N/A'}",
          f"**Composite {fm(A['composite'], 0)}** | Valuation {fm(A['val'], 0)} | Quality {fm(A['qual'], 0)} | "
          f"Strength {fm(A['str'], 0)} | Risk {fm(A['risk'], 0)} (düşük=iyi) | Coverage {fp(A['cov'], 0)} | "
          f"Confidence **{A['conf']}**",
-         f"**Intrinsic value [D]:** {fm(A['iv'])} USD · Margin of Safety {fp(A['mos'])}"]
-    L.append("\n| Yöntem | Değer/hisse | Not |\n|---|---|---|")
+         f"**Fair value [D]:** {fpx(A['iv'])} USDT · Margin of Safety {fp(A['mos'])}"]
+    if d["funding"] is not None:
+        L.append(f"**Perp [R]:** funding {fp(d['funding'], 4)} / 8s · Open interest {fm((d['oi_usd'] or 0) / 1e6, 1) if d['oi_usd'] else 'N/A'} M USD")
+    L.append("\n| Yöntem | Değer | Not |\n|---|---|---|")
     for k, (v, n) in A["methods"].items():
-        L.append(f"| {k} | {fm(v)} | {n} |")
+        L.append(f"| {k} | {fpx(v)} | {n} |")
     if d["flags"]:
         L.append("\n**⚠️ Veri bayrakları:** " + "; ".join(d["flags"]))
-    L.append("\n*Intrinsic = mevcut yöntemlerin medyanı. Skorlar evren içi göreceli, açıklanabilir heuristiklerdir.*")
+    L.append("\n*Fair value = mevcut yöntemlerin medyanı (fiyat-hacim bazlı referans, fundamental değil). "
+             "Skorlar evren içi göreceli, açıklanabilir heuristiklerdir.*")
     return "\n".join(L)
 
 
@@ -791,35 +828,45 @@ def self_test() -> str:
     def chk(name, cond):
         res.append(("✅ " if cond else "❌ ") + name)
 
-    r = dcf_value(100, 0, 0.10, 0, 10, 200)
-    chk("DCF: g=0,tg=0 → EV=1000", r is not None and abs(r["ev"] - 1000) < 1e-6)
-    chk("EV→Equity: 1000-200=800, 80/share", r is not None and abs(r["equity"] - 800) < 1e-6 and abs(r["per_share"] - 80) < 1e-6)
-    chk("DCF refuses wacc<=tg", dcf_value(100, 0.1, 0.05, 0.05, 10, 0) is None)
-    chk("DCF refuses FCF<=0", dcf_value(-5, 0.1, 0.2, 0.05, 10, 0) is None)
-    chk("DCF refuses missing input", dcf_value(100, 0.1, 0.2, 0.05, None, 0) is None)
+    r = dep_value(100, 0, 0.10, 0)
+    chk("DEP: g=0,tg=0, 10% → 100/1.1^5", r is not None and abs(r["per_unit"] - 100 / 1.1 ** 5) < 1e-9)
+    chk("DEP refuses wacc<=tg", dep_value(100, 0.1, 0.05, 0.05) is None)
+    chk("DEP refuses anchor<=0", dep_value(-5, 0.1, 0.2, 0.05) is None)
+    chk("DEP refuses missing input", dep_value(None, 0.1, 0.2, 0.05) is None)
     chk("Real return 50% nom / 25% infl = 20%", abs(real_ret(0.5, 0.25) - 0.2) < 1e-12)
     chk("div by zero → None", div(1, 0) is None and div(None, 2) is None)
     P = dict(infl=0.30, rw=0.10, rtg=0.01, rg=0.03, pt=0.5, conv=0.5)
     g0, w, tg = assumptions(P)
-    chk("WACC > terminal growth (defaults)", w > tg)
+    chk("Discount rate > terminal drift (defaults)", w > tg)
     chk("Probabilities 25/50 → 25/50/25 sum=1", validate_probs(25, 50) is not None and abs(sum(validate_probs(25, 50)) - 1) < 1e-9)
     chk("Probabilities 70/50 rejected", validate_probs(70, 50) is None)
-    # reverse DCF consistency
-    d = {"fcff": 100.0, "shares": 10.0, "net_debt": 200.0, "price": 80.0, "unit_ok": True, "seg": "Industrial"}
+    # reverse valuation consistency
+    d = {"trend_fair": 100.0, "vwap365": 100.0, "sma200": 100.0, "price": 100 / 1.1 ** 5}
     P2 = dict(infl=0.0, rw=0.10, rtg=0.0, rg=0.0, pt=0.0, conv=0.5)
     rows, _ = reverse_dcf(d, P2)
-    chk("Reverse DCF: price 80 → implied g≈0", rows is not None and rows[1]["Implied FCF growth (nominal, yr1)"] == "0.0%")
-    # Piotroski incompleteness
-    empty = {"s": {k: [None, None, None] for k in STMT}}
-    sc, n, _ = piotroski(empty)
-    chk("Piotroski all-missing → 0 available (not 9/9)", n == 0 and sc == 0)
+    chk("Reverse: price = 100/1.1^5 → implied drift≈0",
+        rows is not None and abs(float(rows[1]["Implied drift (nominal, yr1)"].rstrip("%"))) < 0.05)
+    # market health incompleteness
+    sc, n, _ = market_health({})
+    chk("Market health all-missing → 0 available (not 9/9)", n == 0 and sc == 0)
     # peer rule
-    ds = [{"seg": "Industrial", "sector": "X", "pe": 10.0 + i, **{m: None for m in MULTS if m != "pe"}} for i in range(4)]
-    chk("Sector median needs >=5 peers", build_medians(ds)[("Industrial", "X")]["pe"][0] is None)
-    ds += [{"seg": "Industrial", "sector": "X", "pe": 20.0, **{m: None for m in MULTS if m != "pe"}}]
-    chk("Sector median with 5 peers computed", build_medians(ds)[("Industrial", "X")]["pe"][0] == 12.0 or build_medians(ds)[("Industrial", "X")]["pe"][0] is not None)
-    chk("Segment classification", segment_of("Banks - Regional", "JPM") == "Bank" and segment_of("REIT - Industrial", "PLD") == "REIT"
-        and segment_of("Insurance - Life", "MET") == "Insurance" and segment_of("Steel", "NUE") == "Industrial")
+    ds = [{"seg": "X", "p_vwap": 1.0 + 0.1 * i, **{m: None for m in MULTS if m != "p_vwap"}} for i in range(4)]
+    chk("Category median needs >=5 peers", build_medians(ds)["X"]["p_vwap"][0] is None)
+    ds += [{"seg": "X", "p_vwap": 1.2, **{m: None for m in MULTS if m != "p_vwap"}}]
+    chk("Category median with 5 peers computed", build_medians(ds)["X"]["p_vwap"][0] is not None)
+    chk("Symbol normalisation", norm_sym("btc") == "BTC-USDT" and norm_sym("eth/usdt") == "ETH-USDT"
+        and norm_sym("SOLUSDT") == "SOL-USDT" and norm_sym("btc-usdt-swap") == "BTC-USDT" and norm_sym("BTC-USDC") == "BTC-USDC")
+    chk("Stablecoin / leveraged exclusion", is_excluded("USDC") and is_excluded("BTC3L") and not is_excluded("BTC"))
+    # metrics on a deterministic exponential series (+0.1% / day)
+    nd = 400
+    close = 100 * 1.001 ** np.arange(nd)
+    conf = pd.DataFrame({"close": close, "high": close * 1.01, "vol": np.full(nd, 1000.0), "volq": close * 1000.0})
+    mt = metrics_from_candles(conf, float(close[-1] * 1.001), 99.9, 100.1)
+    chk("Metrics: log-trend growth ≈ 1.001^365-1", mt["trend_g"] is not None and abs(mt["trend_g"] - (1.001 ** 365 - 1)) < 1e-6)
+    chk("Metrics: monotonic series → max drawdown 0", mt["maxdd"] is not None and abs(mt["maxdd"]) < 1e-12)
+    chk("Metrics: SMA200 = mean of last 200 closes", mt["sma200"] is not None and abs(mt["sma200"] - close[-200:].mean()) < 1e-9)
+    chk("Metrics: spread 20 bps for 99.9/100.1", mt["spread_bps"] is not None and abs(mt["spread_bps"] - 20.0) < 0.01)
+    chk("Metrics: 90d return", mt["ret90"] is not None and abs(mt["ret90"] - (close[-1] * 1.001 / close[-90] - 1)) < 1e-12)
     return "\n".join(res)
 
 
@@ -827,19 +874,24 @@ def self_test() -> str:
 # GRADIO UI
 # ============================================================================
 
+SORT_COLS = ["Composite", "MoS %", "vs VWAP365 %", "Ret 90d %", "Vol 90d %", "Sharpe 1Y", "MaxDD 1Y %", "Risk",
+             "Exp Return % (12M)", "Real Exp Return %", "Vol30d avg (M USDT)", "Coverage %"]
+
+
 def build_ui():
-    with gr.Blocks(title="US Value Intelligence v3", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("# US Value Intelligence v3\n**⚠️ yfinance verisi point-in-time değildir; backtest için kullanılamaz. "
+    with gr.Blocks(title="OKX Value Intelligence v1", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# OKX Value Intelligence v1\n**⚠️ Veri: OKX public API (spot fiyat/hacim, günlük mumlar, perp funding/OI). "
+                    "Kripto varlıkların bilançosu yoktur: 'Fair value' fiyat-hacim verisinden türetilen istatistiksel referanstır, içsel değer değildir. "
                     "Eksik veri `N/A` gösterilir, asla sıfırla doldurulmaz. 12 aylık senaryolar heuristiktir, istatistiksel tahmin değildir. "
                     "Yatırım tavsiyesi değildir.**")
         with gr.Accordion("⚙️ Varsayımlar [A] (tüm sekmeler için)", open=False):
             with gr.Row():
                 s_infl = gr.Slider(0, 20, 3, step=0.5, label="Enflasyon (%)")
-                s_rw = gr.Slider(1, 20, 7, step=0.5, label="Reel iskonto oranı (%)")
-                s_rtg = gr.Slider(0, 5, 1, step=0.25, label="Reel terminal büyüme (%)")
+                s_rw = gr.Slider(1, 40, 8, step=0.5, label="Reel iskonto / gereken getiri (%)")
+                s_rtg = gr.Slider(0, 15, 3, step=0.25, label="Reel terminal drift (%)")
             with gr.Row():
-                s_rg = gr.Slider(-10, 20, 3, step=0.5, label="Baz reel büyüme (%)")
-                s_pt = gr.Slider(0, 100, 50, step=5, label="Enflasyonun nominal büyümeye geçişi (%)")
+                s_rg = gr.Slider(-30, 60, 8, step=0.5, label="Baz reel drift (%)")
+                s_pt = gr.Slider(0, 100, 50, step=5, label="Enflasyonun nominal drift'e geçişi (%)")
                 s_cv = gr.Slider(0, 100, 50, step=5, label="12 ay içinde değer-fiyat farkının kapanma oranı (%)")
         PI = [s_infl, s_rw, s_rtg, s_rg, s_pt, s_cv]
 
@@ -848,15 +900,16 @@ def build_ui():
                 with gr.Row():
                     scan_btn = gr.Button("Run Scanner", variant="primary", scale=2)
                     force = gr.Checkbox(label="Force refresh", value=False)
-                extra = gr.Textbox(label="Ek tickerlar (virgülle, örn: BRK-B,AAPL)", value="")
+                    perp = gr.Checkbox(label="Perp verisi (funding/OI)", value=True)
+                with gr.Row():
+                    nuni = gr.Slider(20, 200, DEFAULT_UNIVERSE_N, step=10, label="Evren: 24s hacme göre ilk N OKX USDT paritesi")
+                    extra = gr.Textbox(label="Ek pariteler (virgülle, örn: PEPE,WIF,SOL-USDT)", value="")
                 with gr.Row():
-                    f_seg = gr.Dropdown(["All", "Industrial", "Bank", "Insurance", "REIT"], value="All", label="Segment")
+                    f_seg = gr.Dropdown(["All"] + SEGMENTS, value="All", label="Segment")
                     f_c = gr.Slider(0, 100, 0, step=5, label="Min composite")
                     f_m = gr.Slider(-100, 100, -100, step=5, label="Min MoS % (-100 = kapalı)")
                 with gr.Row():
-                    f_sort = gr.Dropdown(["Composite", "MoS %", "P/E", "P/B", "ROE %", "ROIC %", "FCF Yield %", "Risk",
-                                          "Exp Return % (nom, incl div)", "Real Exp Return %", "Coverage %"],
-                                         value="Composite", label="Sırala")
+                    f_sort = gr.Dropdown(SORT_COLS, value="Composite", label="Sırala")
                     f_desc = gr.Checkbox(label="Azalan", value=True)
                     f_btn = gr.Button("Filtreyi uygula")
                 status = gr.Markdown()
@@ -864,14 +917,15 @@ def build_ui():
                 csv = gr.File(label="CSV indir")
                 FI = [f_seg, f_c, f_m, f_sort, f_desc]
 
-                def do_scan(frc, ext, *a, progress=gr.Progress()):
+                def do_scan(frc, prp, nu, ext, *a, progress=gr.Progress()):
                     P = mk_params(*a[:6])
                     seg, c, m, so, de = a[6:]
-                    df, failed = run_scan(frc, ext, P, progress)
+                    SETTINGS["perp"] = bool(prp)
+                    df, failed, src = run_scan(frc, ext, P, progress, nu)
                     if df.empty:
-                        return None, None, "⚠️ Veri çekilemedi."
+                        return None, None, "⚠️ Veri çekilemedi (OKX'e erişilemiyor olabilir)."
                     x, path = apply_filters(seg, c, m, so, de)
-                    msg = f"✅ {len(df)} hisse tarandı · coverage ort. %{df['Coverage %'].mean():.0f}"
+                    msg = f"✅ {len(df)} parite tarandı · evren: {src} · coverage ort. %{df['Coverage %'].mean():.0f}"
                     if failed:
                         msg += f" · ⚠️ Çekilemeyen ({len(failed)}): " + ", ".join(failed)
                     return x, path, msg
@@ -880,12 +934,12 @@ def build_ui():
                     x, path = apply_filters(*a)
                     return x, path
 
-                scan_btn.click(do_scan, [force, extra] + PI + FI, [table, csv, status])
+                scan_btn.click(do_scan, [force, perp, nuni, extra] + PI + FI, [table, csv, status])
                 f_btn.click(do_filter, FI, [table, csv])
 
-            with gr.Tab("🔍 Company Analysis"):
+            with gr.Tab("🔍 Asset Analysis"):
                 with gr.Row():
-                    t1 = gr.Textbox(value="THYAO", label="Ticker", scale=2)
+                    t1 = gr.Textbox(value="BTC", label="Parite (örn: BTC, ETH-USDT)", scale=2)
                     b1 = gr.Button("Analyze", variant="primary")
                 md1 = gr.Markdown()
                 with gr.Row():
@@ -897,13 +951,14 @@ def build_ui():
                     A, err = get_A(t, P)
                     if err:
                         return err, None, None
-                    return md_report(A, P), price_fig(A["d"]["sym"], {"Intrinsic": A["iv"]}), radar_fig(A)
+                    d = A["d"]
+                    return md_report(A, P), price_fig(d, {"Fair value": A["iv"], "VWAP365": d.get("vwap365"), "SMA200": d.get("sma200")}), radar_fig(A)
 
                 b1.click(company, [t1] + PI, [md1, p1, r1])
 
-            with gr.Tab("🧮 Intrinsic Value Calculator"):
+            with gr.Tab("🧮 Fair Value Calculator"):
                 with gr.Row():
-                    t2 = gr.Textbox(value="EREGL", label="Ticker", scale=2)
+                    t2 = gr.Textbox(value="ETH", label="Parite", scale=2)
                     b2 = gr.Button("Calculate", variant="primary")
                 md2 = gr.Markdown()
                 p2 = gr.Plot()
@@ -916,29 +971,26 @@ def build_ui():
                     d = A["d"]
                     g0, w, tg = assumptions(P)
                     L = [f"### {d['sym']} — {d['seg']}",
-                         f"**Varsayımlar [A]:** yıl-1 nominal büyüme {fp(g0)} (reel {fp(P['rg'])}, enflasyon geçişi %{P['pt'] * 100:.0f}) · "
-                         f"nominal iskonto {fp(w)} · nominal terminal {fp(tg)}",
-                         f"**Girdiler [R/D]:** FCFF {fm(d['fcff'], 0)} (FCF + faiz×(1−vergi{' varsayım' if d['tax_assumed'] else ''})) · "
-                         f"net borç {fm(d['net_debt'], 0)} · hisse {fm(d['shares'], 0)} · vergi {fp(d['tax_rate'], 0)}"]
-                    if d["oe_parts"]:
-                        o = d["oe_parts"]
-                        L.append(f"**Owner Earnings [D]:** NI {fm(o['ni'], 0)} + D&A {fm(o['da'], 0)} − bakım capex (tahmin=min(capex, D&A)) "
-                                 f"{fm(o['maint_est'], 0)} + ΔİS sermayesi {fm(o['dwc'], 0)} = **{fm(d['oe'], 0)}** (toplam capex {fm(o['capex_total'], 0)})")
+                         f"**Varsayımlar [A]:** yıl-1 nominal drift {fp(g0)} (reel {fp(P['rg'])}, enflasyon geçişi %{P['pt'] * 100:.0f}) · "
+                         f"nominal iskonto {fp(w)} · nominal terminal drift {fp(tg)}",
+                         f"**Fiyat çıpaları [D]:** Log-trend {fpx(d.get('trend_fair'))} · VWAP365 {fpx(d.get('vwap365'))} · SMA200 {fpx(d.get('sma200'))} "
+                         f"→ DEP çıpası (medyan) **{fpx(anchor_of(d))}**",
+                         f"**Trend [D]:** yıllık log-trend drift {fp(d.get('trend_g'))} · fiyatın trende göre sapması z={fm(d.get('trend_z'))}σ"]
                     L.append("\n| Yöntem | Değer | Not |\n|---|---|---|")
                     for k, (v, n) in A["methods"].items():
-                        L.append(f"| {k} | {fm(v)} | {n} |")
-                    L.append(f"\n**Intrinsic (medyan): {fm(A['iv'])}** · Fiyat {fm(d['price'])} · MoS {fp(A['mos'])}")
+                        L.append(f"| {k} | {fpx(v)} | {n} |")
+                    L.append(f"\n**Fair value (medyan): {fpx(A['iv'])}** · Fiyat {fpx(d['price'])} · MoS {fp(A['mos'])}")
                     names = [k for k, (v, _) in A["methods"].items() if v]
                     vals = [A["methods"][k][0] for k in names]
-                    f = go.Figure(go.Bar(x=["Price"] + names + ["Intrinsic"], y=[d["price"]] + vals + [A["iv"] or 0]))
+                    f = go.Figure(go.Bar(x=["Price"] + names + ["Fair value"], y=[d["price"]] + vals + [A["iv"] or 0]))
                     f.update_layout(template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
                     return "\n".join(L), f
 
                 b2.click(calc, [t2] + PI, [md2, p2])
 
-            with gr.Tab("↩️ Reverse DCF"):
+            with gr.Tab("↩️ Reverse Valuation"):
                 with gr.Row():
-                    t3 = gr.Textbox(value="TOASO", label="Ticker", scale=2)
+                    t3 = gr.Textbox(value="SOL", label="Parite", scale=2)
                     b3 = gr.Button("Solve", variant="primary")
                 md3 = gr.Markdown()
                 tb3 = gr.Dataframe(interactive=False)
@@ -953,18 +1005,17 @@ def build_ui():
                     if rows is None:
                         return f"**{d['sym']}**: ⚠️ {note}", None
                     g0, _, _ = assumptions(P)
-                    h = d["s"]["fcf"]
-                    hist = f"{fp((h[0] / h[2]) ** 0.5 - 1)}" if (h[0] or 0) > 0 and (h[2] or 0) > 0 else "N/A"
-                    md = (f"**{d['sym']}** fiyat {fm(d['price'])} → piyasanın fiyatladığı FCF büyümesi (5 yıl, terminale doğru sönümlenir).\n\n"
-                          f"Mevcut varsayım yıl-1 büyüme: {fp(g0)} · Tarihsel FCF CAGR (2y, nominal): {hist}\n\n"
-                          "Not: Zorunlu bir 'doğru' yoktur; implied büyüme makul görünmüyorsa piyasa beklentisi ya aşırı iyimser ya da kötümserdir.")
+                    md = (f"**{d['sym']}** fiyat {fpx(d['price'])} → piyasanın fiyatladığı yıl-1 drift (5 yıl, terminale doğru sönümlenir; çıpa {fpx(anchor_of(d))}).\n\n"
+                          f"Mevcut varsayım yıl-1 drift: {fp(g0)} · Tarihsel log-trend drift (yıllık): {fp(d.get('trend_g'))} · "
+                          f"Son 365g getiri: {fp(d.get('ret365'))}\n\n"
+                          "Not: Zorunlu bir 'doğru' yoktur; implied drift makul görünmüyorsa piyasa beklentisi ya aşırı iyimser ya da kötümserdir.")
                     return md, pd.DataFrame(rows)
 
                 b3.click(rev, [t3] + PI, [md3, tb3])
 
-            with gr.Tab("💎 Financial Quality"):
+            with gr.Tab("💎 Market Quality"):
                 with gr.Row():
-                    t4 = gr.Textbox(value="BIMAS", label="Ticker", scale=2)
+                    t4 = gr.Textbox(value="BTC", label="Parite", scale=2)
                     b4 = gr.Button("Show", variant="primary")
                 md4 = gr.Markdown()
                 tb4 = gr.Dataframe(interactive=False)
@@ -977,25 +1028,29 @@ def build_ui():
                         return err, None, None
                     q, d = A["q"], A["d"]
                     pc = lambda x: fp(x)
-                    rows = [("ROE [D]", pc(q["roe"])), ("ROE (reel) [D]", pc(real_ret(q["roe"], P["infl"]))), ("ROA [D]", pc(q["roa"])),
-                            ("ROIC [D]", pc(q["roic"])), ("Gross margin [D]", pc(q["gm"])), ("Operating margin [D]", pc(q["opm"])),
-                            ("Net margin [D]", pc(q["npm"])), ("Debt/Equity % [D]", fm(q["de"], 0)), ("Net debt/EBITDA [D]", fm(q["nd_ebitda"])),
-                            ("Current ratio [D]", fm(q["cr"])), ("Interest coverage [D]", fm(q["icov"])), ("FCF/NI [D]", fm(q["fcf_conv"])),
-                            ("FCF variation (CV) [D]", fm(q["fcf_cv"])), ("Revenue growth nominal [D]", pc(q["rev_g"])),
-                            ("Revenue growth real [D]", pc(real_ret(q["rev_g"], P["infl"]))), ("Earnings growth nominal [D]", pc(q["ni_g"])),
-                            ("Earnings growth real [D]", pc(real_ret(q["ni_g"], P["infl"]))), ("Equity/Assets [D]", pc(q["eq_ta"]))]
+                    rows = [("Return 30d [D]", pc(q["ret30"])), ("Return 90d [D]", pc(q["ret90"])), ("Return 365d [D]", pc(q["ret365"])),
+                            ("Return 365d (reel) [D]", pc(real_ret(q["ret365"], P["infl"]))),
+                            ("Volatility 30d (ann.) [D]", pc(q["vol30"])), ("Volatility 90d (ann.) [D]", pc(q["vol90"])),
+                            ("Volatility 365d (ann.) [D]", pc(q["vol365"])), ("Sharpe 1Y (rf=0) [D]", fm(q["sharpe"])),
+                            ("Sortino 1Y [D]", fm(q["sortino"])), ("Max drawdown 1Y [D]", pc(q["maxdd"])),
+                            ("Drawdown from 1Y high [D]", pc(q["dd_high"])), ("SMA50 / SMA200 gap [D]", pc(q["sma_gap"])),
+                            ("Trend z-score [D]", fm(q["trend_z"])), ("Spread (bps) [R]", fm(q["spread_bps"], 1)),
+                            ("Avg daily volume 30d (M USDT) [R]", fm(None if q["vq30"] is None else q["vq30"] / 1e6, 1)),
+                            ("Volume 30d / 90d [D]", fm(q["vol_ratio"])), ("Volume variation (CV) [D]", fm(q["vcv"])),
+                            ("Worst day (90d) [D]", pc(q["worst90"])), ("Daily VaR95 (90d) [D]", pc(q["var95"])),
+                            ("Funding (8h) [R]", fp(d["funding"], 4)), ("History (days) [R]", fm(q["hist_days"], 0))]
                     sc, n, comps = A["pio"]
                     cp = [(c, "N/A" if v is None else ("1" if v else "0")) for c, v in comps]
-                    md = (f"**{d['sym']}** — Piotroski: **{sc}/{n}** (hesaplanabilen {n}/9)" +
+                    md = (f"**{d['sym']}** — Market health: **{sc}/{n}** (hesaplanabilen {n}/9)" +
                           ("" if n == 9 else " ⚠️ eksik bileşen var; skor tam değildir.") +
-                          (" Bankalar için Piotroski sınırlı anlam taşır." if d["seg"] in ("Bank", "Insurance") else ""))
-                    return md, pd.DataFrame(rows, columns=["Metric", "Value"]), pd.DataFrame(cp, columns=["Piotroski component", "Result"])
+                          (" Perp bulunmayan varlıklarda funding bileşeni N/A olur." if d["funding"] is None else ""))
+                    return md, pd.DataFrame(rows, columns=["Metric", "Value"]), pd.DataFrame(cp, columns=["Health component", "Result"])
 
                 b4.click(qual, [t4] + PI, [md4, tb4, tb4b])
 
             with gr.Tab("🛡️ Risk Analysis"):
                 with gr.Row():
-                    t5 = gr.Textbox(value="PGSUS", label="Ticker", scale=2)
+                    t5 = gr.Textbox(value="DOGE", label="Parite", scale=2)
                     b5 = gr.Button("Assess", variant="primary")
                 md5 = gr.Markdown()
                 tb5 = gr.Dataframe(interactive=False)
@@ -1011,9 +1066,9 @@ def build_ui():
 
                 b5.click(risk_tab, [t5] + PI, [md5, tb5])
 
-            with gr.Tab("🏭 Sector Comparison"):
+            with gr.Tab("🏭 Category Comparison"):
                 with gr.Row():
-                    t6 = gr.Textbox(value="EREGL", label="Ticker (opsiyonel)", scale=2)
+                    t6 = gr.Textbox(value="SOL", label="Parite (opsiyonel)", scale=2)
                     b6 = gr.Button("Compare", variant="primary")
                 md6 = gr.Markdown()
                 tb6 = gr.Dataframe(interactive=False)
@@ -1023,23 +1078,24 @@ def build_ui():
                     P = mk_params(*a)
                     ds = cached_ds()
                     if not ds:
-                        return "Önce Market Scanner'ı çalıştırın (medyanlar önbellekteki hisselerden hesaplanır).", None, None
+                        return "Önce Market Scanner'ı çalıştırın (medyanlar önbellekteki paritelerden hesaplanır).", None, None
                     med = build_medians(ds)
                     rows = []
-                    for (seg, sec), m in sorted(med.items()):
-                        r = {"Segment": seg, "Sector": sec, "Peers": sum(1 for d in ds if d["seg"] == seg and d["sector"] == sec)}
-                        for f in ("pe", "pb", "ev_ebitda", "ev_fcf", "ps", "fcf_yield", "earn_yield"):
+                    for seg, m in sorted(med.items()):
+                        r = {"Segment": seg, "Peers": sum(1 for d in ds if d["seg"] == seg)}
+                        for f in MULTS:
                             v, n = m[f]
                             r[f] = None if v is None else round(v, 3)
                         rows.append(r)
-                    fig, md = None, f"Sektör medyanı için en az {MIN_PEERS} geçerli peer gerekir; yetersizse `None`."
+                    fig, md = None, (f"Kategori medyanı için en az {MIN_PEERS} geçerli peer gerekir; yetersizse `None`. "
+                                     "p_vwap = fiyat/VWAP365, p_sma200 = fiyat/SMA200, p_trend = fiyat/log-trend, p_high = fiyat/1Y zirve.")
                     d = fetch(norm_sym(t)) if t.strip() else None
                     if d:
-                        m = med.get((d["seg"], d["sector"]))
-                        keys = ["pe", "pb", "ev_ebitda", "ps"]
+                        m = med.get(d["seg"])
+                        keys = ["p_vwap", "p_sma200", "p_trend", "p_high"]
                         cv_ = [d[k] for k in keys]
                         mv = [m[k][0] if m else None for k in keys]
-                        fig = go.Figure([go.Bar(name=d["sym"], x=keys, y=cv_), go.Bar(name="Sector median", x=keys, y=mv)])
+                        fig = go.Figure([go.Bar(name=d["sym"], x=keys, y=cv_), go.Bar(name="Category median", x=keys, y=mv)])
                         fig.update_layout(barmode="group", template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
                         md = f"**{d['sym']}** — {d['seg']} / {d['sector']}. " + md
                     return md, pd.DataFrame(rows), fig
@@ -1048,7 +1104,7 @@ def build_ui():
 
             with gr.Tab("🎯 12-Month Scenarios"):
                 with gr.Row():
-                    t7 = gr.Textbox(value="AKBNK", label="Ticker", scale=2)
+                    t7 = gr.Textbox(value="BTC", label="Parite", scale=2)
                     pb = gr.Slider(0, 100, 25, step=5, label="Bear olasılığı (%)")
                     pm = gr.Slider(0, 100, 50, step=5, label="Base olasılığı (%) — Bull = kalan")
                     b7 = gr.Button("Run", variant="primary")
@@ -1066,16 +1122,14 @@ def build_ui():
                         return err, None, None
                     d, e = A["d"], A["exp"]
                     rows = [{"Scenario": o["Scenario"], "Real growth": o["Real growth"], "Real disc. rate": o["Real disc. rate"],
-                             "Multiple factor": o["Multiple factor"], "Intrinsic": None if o["Intrinsic"] is None else round(o["Intrinsic"], 2),
-                             "12M target": None if o["Target"] is None else round(o["Target"], 2),
-                             "Probability": f"{o['Prob'] * 100:.0f}%"} for o in A["scen"]]
+                             "Multiple factor": o["Multiple factor"], "Fair value": rsig(o["Intrinsic"]),
+                             "12M target": rsig(o["Target"]), "Probability": f"{o['Prob'] * 100:.0f}%"} for o in A["scen"]]
                     if e is None:
-                        return f"**{d['sym']}**: ⚠️ Senaryo üretilemedi (intrinsic value hesaplanamadı).", pd.DataFrame(rows), None
-                    md = (f"**{d['sym']}** · Olasılık-ağırlıklı hedef **{fm(e['pw'])}** · Beklenen nominal fiyat getirisi {fp(e['nominal'])} · "
-                          f"Temettü-dahil nominal {fp(e['total'])}" + ("" if e["dy_known"] else " (temettü verisi yok, 0 sayıldı)") +
-                          f" · Reel (temettü-dahil) {fp(e['real'])} · Reel fiyat getirisi {fp(e['real_price'])}\n\n"
+                        return f"**{d['sym']}**: ⚠️ Senaryo üretilemedi (fair value hesaplanamadı).", pd.DataFrame(rows), None
+                    md = (f"**{d['sym']}** · Olasılık-ağırlıklı hedef **{fpx(e['pw'])}** · Beklenen nominal fiyat getirisi {fp(e['nominal'])} · "
+                          f"Reel getiri {fp(e['real'])} (spot: temettü/gelir yok, getiri yalnızca fiyat)\n\n"
                           f"*Heuristik: hedef = fiyat + k×(senaryo değeri − fiyat), k={P['conv'] * 100:.0f}%, çarpan faktörü uygulanır. "
-                          "İstatistiksel olarak doğrulanmış tahmin değildir. Temettü yalnızca bir kez eklenir.*")
+                          "İstatistiksel olarak doğrulanmış tahmin değildir.*")
                     f = go.Figure(go.Bar(x=["Price", "Bear", "Base", "Bull", "Prob-weighted"],
                                          y=[d["price"]] + [o["Target"] for o in A["scen"]] + [e["pw"]]))
                     f.update_layout(template="plotly_white", height=340, margin=dict(l=10, r=10, t=20, b=10))
@@ -1089,19 +1143,21 @@ def build_ui():
                 tb8 = gr.Dataframe(interactive=False, wrap=True)
 
                 def dq(progress=gr.Progress()):
+                    uni = LAST["universe"] or build_universe(DEFAULT_UNIVERSE_N)[0]
                     rows, failed = [], []
-                    for i, s in enumerate(US_UNIVERSE):
-                        progress((i + 1) / len(US_UNIVERSE), desc=f"Checking {s}")
+                    for i, s in enumerate(uni):
+                        progress((i + 1) / len(uni), desc=f"Checking {s}")
                         was = _cget(f"t_{s}") is not None
                         d = fetch(s)
                         if d is None:
                             failed.append(s)
                             continue
                         c = coverage(d)
-                        rows.append({"Ticker": d["sym"], "Segment": d["seg"], "Coverage %": round(c * 100),
-                                     "Statement date": d["stmt_date"].date().isoformat() if d["stmt_date"] else "N/A",
-                                     "Age (days)": d["age"], "Status": "OK" if c >= 0.7 and not d["flags"] else "CHECK",
-                                     "Flags": "; ".join(d["flags"]) or "—"})
+                        rows.append({"Pair": d["sym"], "Segment": d["seg"], "Coverage %": round(c * 100),
+                                     "Last candle": d["last_dt"].date().isoformat() if d["last_dt"] is not None else "N/A",
+                                     "Age (h)": round(d["age_h"]), "History (days)": d["hist_days"],
+                                     "Status": "OK" if c >= 0.7 and not d["flags"] else "CHECK",
+                                     "Flags": "; ".join(d["flags"] + d["notes"]) or "—"})
                         if not was:
                             time.sleep(REQUEST_DELAY_SEC * 0.5)
                     df = pd.DataFrame(rows)
@@ -1120,33 +1176,40 @@ def build_ui():
 
 
 METHODOLOGY = """
-### Değerleme mimarisi
-- **DCF (sanayi/REIT dışı):** FCFF = FCF + faiz×(1−vergi) (Yahoo FCF'si faiz sonrası olduğu için borç çift sayılmasın diye). 5 yıl, büyüme yıl-1'den terminale doğrusal sönümlenir; EV − net borç = özsermaye; / hisse. Girdi eksik, FCFF ≤ 0 veya iskonto ≤ terminal büyüme ise **hesaplanmaz**.
-- **Owner Earnings:** NI + D&A − bakım capex + ΔİSermayesi. Bakım capex = min(toplam capex, D&A) **tahminidir**; veri eksikse yöntem kullanılmaz. Özsermaye nakit akışı olduğu için net borç düşülmez.
-- **Banka/Sigorta:** Gordon gerekçeli P/B = (sürdürülebilir ROE − g)/(COE − g) × defter değeri. FCF/EV-EBITDA kullanılmaz. Sermaye yeterliliği/aktif kalitesi Yahoo'da yok.
-- **REIT:** NAV vekili = defter değeri (ekspertiz NAV'ı yok), P/NAV. Doluluk verisi yok.
-- **Relative:** sektör medyanı (en az 5 geçerli peer) P/E, P/B, EV/EBITDA → hisse başına değer.
-- **Intrinsic = mevcut yöntemlerin medyanı.** MoS = (IV − fiyat)/IV.
-- **Reverse DCF:** fiyatı veren yıl-1 FCF büyümesi (bisection), iskonto oranı ±3 puan duyarlılığı.
-- **Enflasyon:** iskonto ve terminal büyüme reel girilir, nominale çevrilir; enflasyonun yalnızca ayarlanabilir bir kısmı (geçiş oranı) kâr büyümesine yansır. Reel getiri = (1+nominal)/(1+enflasyon) − 1.
-- **Senaryolar:** Bear/Base/Bull = reel büyüme ∓4 puan, reel iskonto +3/−2 puan, çarpan faktörü 0.85/1.0/1.10; hedef = fiyat + k×(değer − fiyat). Olasılıklar ayarlanabilir, toplam %100 (Bull = kalan).
+### Veri
+- **Kaynak:** yalnızca OKX public API (anahtar gerekmez): spot ticker (fiyat, bid/ask, 24s hacim), 500 günlük **günlük mumlar** (UTC), perp **funding rate** ve **open interest**.
+- **Evren:** 24s USDT hacmine göre ilk N OKX spot USDT paritesi (stablecoin ve kaldıraçlı tokenlar hariç, min 1M USDT/24s) + eklediğiniz pariteler. Ticker listesi alınamazsa gömülü yedek liste kullanılır.
+- Metrikler yalnızca **kapanmış** günlük mumlardan hesaplanır; canlı fiyat ticker'dan gelir.
+
+### Değerleme mimarisi (fundamental yoktur → fiyat-bazlı fair value)
+- **Log-Trend Regression:** son ≤500 günün ln(fiyat) doğrusal regresyonunun bugünkü değeri; yıllık trend drift'i ve fiyatın trendden σ cinsinden sapması (z) raporlanır.
+- **VWAP 365D:** hacim-ağırlıklı ortalama fiyat (yatırımcı maliyet bazı vekili). **SMA 200D:** uzun vadeli ortalama.
+- **Discounted Expected Price (DEP):** DCF'in nakit akışsız karşılığı. Çıpa = (trend, VWAP, SMA200) medyanı; 5 yıl boyunca yıl-1 drift'inden terminal drift'e doğrusal sönen büyüme uygulanır, gereken getiri (iskonto) ile bugüne indirgenir. Çıpa eksikse veya iskonto ≤ terminal drift ise **hesaplanmaz**.
+- **Relative:** kategori medyanı (en az 5 geçerli peer) p_vwap, p_sma200, p_trend çarpanları × varlığın kendi VWAP/SMA200/trend değeri.
+- **Fair value = mevcut yöntemlerin medyanı.** MoS = (FV − fiyat)/FV. Bu bir içsel değer değil, istatistiksel referanstır.
+- **Reverse Valuation:** fiyatı veren yıl-1 drift (bisection), iskonto oranı ±3 puan duyarlılığı.
+- **Enflasyon:** iskonto ve terminal drift reel girilir, nominale çevrilir; enflasyonun yalnızca ayarlanabilir bir kısmı drift'e yansır. Reel getiri = (1+nominal)/(1+enflasyon) − 1.
+- **Senaryolar:** Bear/Base/Bull = reel drift ∓4 puan, reel iskonto +3/−2 puan, çarpan faktörü 0.85/1.0/1.10; hedef = fiyat + k×(değer − fiyat). Olasılıklar ayarlanabilir, toplam %100 (Bull = kalan). Spot'ta temettü/gelir olmadığından getiri yalnızca fiyattır.
 
 ### Skorlama (0-100, açıklanabilir)
 Composite = ağırlıklı ortalama (mevcut bileşenler üzerinden yeniden normalize) × min(1, coverage/0.7).
 | Segment | Valuation | Quality | Strength | Risk (ters) |
 |---|---|---|---|---|
-| Sanayi | 35 | 30 | 20 | 15 |
-| Banka | 40 | 35 | 10 | 15 |
-| Sigorta | 40 | 30 | 15 | 15 |
-| REIT | 45 | 20 | 20 | 15 |
+| Majors | 30 | 25 | 25 | 20 |
+| Meme | 25 | 15 | 20 | 40 |
+| Diğer (Alt L1, DeFi, Infra/L2, AI/Gaming, Other) | 30 | 25 | 20 | 25 |
 
-Risk (0-100): 10 bayrak (distress, kaldıraç, likidite, negatif FCF, kâr/marj bozulması, CFO-NI ayrışması, seyrelme, aşırı değerleme, veri güvenilirliği); yalnızca değerlendirilebilen bayrakların ağırlığı üzerinden hesaplanır. Piotroski 9 bileşenli; hesaplanamayan bileşen "N/A" olur ve skor `x/n` olarak gösterilir.
+- **Valuation:** MoS, göreli MoS, trend z-score, fiyat/SMA200, 1Y zirveden iskonto.
+- **Quality:** reel 365g getiri, Sharpe, Sortino, max drawdown, reel 90g getiri, hacim istikrarı.
+- **Strength:** likidite (30g ort. hacim), spread, geçmiş uzunluğu, volatilite rejimi, market health skoru.
+- **Market Health (9 bileşen, Piotroski benzeri):** fiyat>SMA200, SMA50>SMA200, 90g getiri>0, volatilite düşüyor, hacim küçülmüyor, zirveden düşüş<%40, Sharpe>0, spread<10bps, funding kalabalık değil. Hesaplanamayan bileşen "N/A" olur ve skor `x/n` gösterilir.
+- **Risk (0-100):** 11 bayrak (aşırı volatilite, derin drawdown, düşüş trendi, ince likidite, geniş spread, hacim çöküşü, crash günü, VaR95, aşırı uzama, funding kalabalığı, veri güvenilirliği); yalnızca değerlendirilebilen bayrakların ağırlığı üzerinden hesaplanır.
 
 ### Bilinen veri sınırlamaları
-- yfinance point-in-time değildir; backtest geçersizdir. Bilanço tarihleri ve kapsam hisseden hisseye değişir.
-- Yıllık tablolar gecikmelidir; Yıllık tablolar GAAP/ADR farklarına ve tek seferlik kalemlere duyarlıdır; yabancı (ADR) şirketlerde para birimi uyuşmazlığı bayraklanır.
-- Evren: gömülü liste + eklediğiniz tickerlar (tüm ABD piyasası Yahoo'dan ücretsiz çekilemez).
-- Sektör/segment sınıflaması Yahoo `industry` alanına dayanır; peer sayısı <5 ise medyan hesaplanmaz.
+- Fundamental/on-chain/market-cap verisi yoktur; fair value yalnızca fiyat-hacim geçmişine dayanır ve geçmiş trendin sürmesini ima etmez.
+- Yeni listelenen paritelerde geçmiş kısadır (SMA200/VWAP/trend hesaplanamayabilir → N/A, düşük coverage).
+- Kategori sınıflaması gömülü bir haritaya dayanır; haritada olmayan varlıklar "Other" olur. Peer sayısı <5 ise medyan hesaplanmaz.
+- OKX public API hız limitine tabidir; tarama sırasında istekler yavaşlatılır, 429/50011 hatalarında tekrar denenir.
 - Sonuçlar araştırma/eğitim amaçlıdır, yatırım tavsiyesi değildir.
 """