diff --git a/.github/workflows/cache_refresh.yml b/.github/workflows/cache_refresh.yml
new file mode 100644
index 0000000..a969454
--- /dev/null
+++ b/.github/workflows/cache_refresh.yml
@@ -0,0 +1,35 @@
+name: Refresh Analyst Cache
+
+on:
+  schedule:
+    - cron: '0 7 * * 1-5'   # 02:00 AM EST (07:00 UTC), Mon–Fri only
+  workflow_dispatch:          # allow manual trigger from the GitHub Actions UI
+
+jobs:
+  refresh:
+    runs-on: ubuntu-latest
+    timeout-minutes: 90       # analyst phase ~50 min + news phase ~6 min
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python 3.11
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          pip install --upgrade pip
+          pip install \
+            yfinance>=0.2.36 \
+            pandas>=2.0.0 \
+            requests>=2.28.0 \
+            vaderSentiment>=3.3.2
+
+      - name: Run cache builder
+        env:
+          SUPABASE_URL: ${{ secrets.SUPABASE_URL }}
+          SUPABASE_SERVICE_KEY: ${{ secrets.SUPABASE_SERVICE_KEY }}
+        run: python cache_builder.py
diff --git a/.gitignore b/.gitignore
index 331f6cb..f591f23 100644
Binary files a/.gitignore and b/.gitignore differ
diff --git a/StockScreener.spec b/StockScreener.spec
index aae3669..786650e 100644
--- a/StockScreener.spec
+++ b/StockScreener.spec
@@ -3,25 +3,24 @@ from PyInstaller.utils.hooks import collect_all
 
 datas = []
 binaries = []
-hiddenimports = [
-    'pandas', 'numpy', 'yfinance', 'requests',
-    'lxml', 'lxml.etree', 'html5lib', 'bs4',
-    'appdirs', 'platformdirs',
-    'tkinter', 'tkinter.ttk', 'tkinter.messagebox',
-    'screener_gui', 'stock_screener',
-    'matplotlib', 'matplotlib.backends.backend_tkagg',
-    'matplotlib.figure', 'matplotlib.dates', 'matplotlib.ticker',
-    'winreg',
-    'hwid', 'license_check', 'activation_dialog', 'updater',
-]
-
+hiddenimports = ['pandas', 'numpy', 'yfinance', 'requests', 'lxml', 'lxml.etree', 'html5lib', 'bs4', 'appdirs', 'platformdirs', 'tkinter', 'tkinter.ttk', 'tkinter.messagebox', 'screener_gui', 'stock_screener', 'matplotlib', 'matplotlib.backends.backend_tkagg', 'matplotlib.figure', 'matplotlib.dates', 'matplotlib.ticker', 'winreg', 'ssl', '_ssl', 'certifi', 'charset_normalizer', 'hwid', 'license_check', 'activation_dialog', 'updater', 'vaderSentiment', 'vaderSentiment.vaderSentiment']
+tmp_ret = collect_all('pandas')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
+tmp_ret = collect_all('numpy')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
 tmp_ret = collect_all('yfinance')
 datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
-
 tmp_ret = collect_all('matplotlib')
 datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
-
-tmp_ret = collect_all('pandas')
+tmp_ret = collect_all('requests')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
+tmp_ret = collect_all('certifi')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
+tmp_ret = collect_all('charset_normalizer')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
+tmp_ret = collect_all('vaderSentiment')
+datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
+tmp_ret = collect_all('tzdata')
 datas += tmp_ret[0]; binaries += tmp_ret[1]; hiddenimports += tmp_ret[2]
 
 
@@ -38,10 +37,7 @@ a = Analysis(
     noarchive=False,
     optimize=0,
 )
-
-# Bytecode encryption key (requires tinyaes + PyInstaller 5.x)
-# If your PyInstaller version does not support this, remove the key= line.
-pyz = PYZ(a.pure, cipher=None)  # swap cipher=None for cipher=block_cipher if using --key
+pyz = PYZ(a.pure)
 
 exe = EXE(
     pyz,
@@ -53,7 +49,7 @@ exe = EXE(
     debug=False,
     bootloader_ignore_signals=False,
     strip=False,
-    upx=True,
+    upx=False,
     upx_exclude=[],
     runtime_tmpdir=None,
     console=False,
@@ -62,4 +58,5 @@ exe = EXE(
     target_arch=None,
     codesign_identity=None,
     entitlements_file=None,
+    uac_admin=True,   # embed UAC manifest: always run as Administrator
 )
diff --git a/activation_dialog.py b/activation_dialog.py
index 7146baf..76fbd20 100644
--- a/activation_dialog.py
+++ b/activation_dialog.py
@@ -7,24 +7,84 @@ saves it to disk so it won't be asked again.
 """
 
 import tkinter as tk
-from tkinter import ttk
 
 import license_check
-from hwid import get_hwid
 
-# ---- Colors matching the screener's dark theme ----
-_BG       = "#1e1e2e"
-_PANEL    = "#2a2a3e"
-_ACCENT   = "#4f8ef7"
-_TEXT     = "#e0e0f0"
-_SUBTEXT  = "#888899"
-_ERROR    = "#ff6b6b"
-_SUCCESS  = "#50fa7b"
-_BORDER   = "#3a3a5e"
-_ENTRY_BG = "#12121f"
+# ---- Colors — exact match to the main app theme ----
+_BG      = "#000000"
+_ACCENT  = "#00e676"
+_TEXT    = "#ffffff"
+_SUBTEXT = "#555555"
+_ERROR   = "#ff4545"
+_SUCCESS = "#00e676"
+_BORDER  = "#0d0d0d"
 
 
-def run_activation() -> bool:
+# ---- Shared pill-shape helper ------------------------------------------------
+
+def _pill_pts(w, h, r=10):
+    return [r,0, w-r,0, w,0, w,r, w,h-r, w,h, w-r,h, r,h, 0,h, 0,h-r, 0,r, 0,0]
+
+
+# ---- Pill entry (borderless green canvas entry) ------------------------------
+
+def _make_pill_entry(parent, textvariable, width_px=380, height_px=40,
+                     font=("Consolas", 11)):
+    """Return a (frame, entry) tuple — a pill-shaped green entry."""
+    r = height_px // 2
+    frame = tk.Frame(parent, bg=_BG, bd=0, highlightthickness=0)
+    cv = tk.Canvas(frame, width=width_px, height=height_px,
+                   highlightthickness=0, bd=0, bg=_BG)
+    cv.pack()
+    pts = _pill_pts(width_px, height_px, r)
+    cv.create_polygon(pts, smooth=True, fill=_ACCENT, outline=_ACCENT, width=0)
+    inner = tk.Frame(cv, bg=_ACCENT, bd=0, highlightthickness=0)
+    cv.create_window(width_px // 2, height_px // 2, window=inner,
+                     width=width_px - 10, height=height_px - 8)
+    entry = tk.Entry(inner, textvariable=textvariable,
+                     font=font, bg=_ACCENT, fg="#000000",
+                     insertbackground="#000000", relief="flat",
+                     bd=0, highlightthickness=0)
+    entry.pack(fill="x", expand=True, padx=8, ipady=2)
+    return frame, entry
+
+
+# ---- Pill button (borderless canvas button) ----------------------------------
+
+class _PillBtn(tk.Canvas):
+    def __init__(self, parent, text, command,
+                 width=120, height=36, radius=10,
+                 bg=_ACCENT, fg="#000000"):
+        super().__init__(parent, width=width, height=height,
+                         highlightthickness=0, bd=0, bg=parent.cget("bg"))
+        self._bg      = bg
+        self._fg      = fg
+        self._command = command
+        self._enabled = True
+        pts = _pill_pts(width, height, radius)
+        self._rect = self.create_polygon(pts, smooth=True,
+                                          fill=bg, outline=bg, width=0)
+        self._lbl  = self.create_text(width // 2, height // 2,
+                                       text=text, fill=fg,
+                                       font=("Segoe UI", 10, "bold"))
+        self.config(cursor="hand2")
+        self.bind("<Button-1>", lambda _e: self._command() if self._enabled else None)
+        self.bind("<Enter>",    lambda _e: self.itemconfig(self._rect, fill="#00c060") if self._enabled else None)
+        self.bind("<Leave>",    lambda _e: self.itemconfig(self._rect, fill=self._bg))
+
+    def set_enabled(self, enabled: bool):
+        self._enabled = enabled
+        self.itemconfig(self._rect, fill=self._bg if enabled else _BORDER)
+        self.itemconfig(self._lbl,  fill=self._fg if enabled else _SUBTEXT)
+        self.config(cursor="hand2" if enabled else "")
+
+    def set_text(self, text: str):
+        self.itemconfig(self._lbl, text=text)
+
+
+# ---- Main dialog ------------------------------------------------------------
+
+def run_activation(hwid: str) -> bool:
     """
     Open the activation dialog and block until the user either activates
     successfully or closes the window.
@@ -34,7 +94,7 @@ def run_activation() -> bool:
     activated = [False]
 
     root = tk.Tk()
-    root.title("Ultimate Investment Tool — Activation")
+    root.title("Ultimate Investment Tool — License Activation")
     root.configure(bg=_BG)
     root.resizable(False, False)
 
@@ -45,108 +105,78 @@ def run_activation() -> bool:
     y = (root.winfo_screenheight() - h) // 2
     root.geometry(f"{w}x{h}+{x}+{y}")
 
-    # Intercept close button — same as clicking Exit
     root.protocol("WM_DELETE_WINDOW", lambda: _on_exit(root, activated))
 
-    # ---- Header ----
-    header = tk.Frame(root, bg=_ACCENT, height=4)
-    header.pack(fill="x")
+    # ---- Header accent bar ----
+    tk.Frame(root, bg=_ACCENT, height=4).pack(fill="x")
 
-    tk.Label(
-        root, text="Ultimate Investment Tool",
-        font=("Segoe UI", 16, "bold"),
-        bg=_BG, fg=_TEXT
-    ).pack(pady=(28, 4))
+    tk.Label(root, text="Ultimate Investment Tool",
+             font=("Segoe UI", 16, "bold"),
+             bg=_BG, fg=_TEXT).pack(pady=(28, 4))
 
-    tk.Label(
-        root, text="Enter your license key to activate this software.",
-        font=("Segoe UI", 9),
-        bg=_BG, fg=_SUBTEXT
-    ).pack()
-
-    # ---- Key entry ----
-    entry_frame = tk.Frame(root, bg=_PANEL, bd=0, highlightthickness=1,
-                           highlightbackground=_BORDER)
-    entry_frame.pack(padx=40, pady=24, fill="x")
+    tk.Label(root, text="Enter your license key to activate this software.",
+             font=("Segoe UI", 9),
+             bg=_BG, fg=_SUBTEXT).pack()
 
+    # ---- Pill key entry ----
     key_var = tk.StringVar()
-    key_entry = tk.Entry(
-        entry_frame, textvariable=key_var,
-        font=("Consolas", 11), bg=_ENTRY_BG, fg=_TEXT,
-        insertbackground=_TEXT, relief="flat",
-        bd=10, width=36
-    )
-    key_entry.pack(fill="x")
+    ef, key_entry = _make_pill_entry(root, key_var, width_px=400, height_px=42)
+    ef.pack(pady=22)
     key_entry.focus()
 
     # ---- Status label ----
     status_var = tk.StringVar(value="")
-    status_label = tk.Label(
-        root, textvariable=status_var,
-        font=("Segoe UI", 9),
-        bg=_BG, fg=_ERROR, wraplength=400
-    )
+    status_label = tk.Label(root, textvariable=status_var,
+                            font=("Segoe UI", 9),
+                            bg=_BG, fg=_ERROR, wraplength=420)
     status_label.pack(pady=(0, 8))
 
-    # ---- Buttons ----
+    # ---- Pill buttons ----
     btn_frame = tk.Frame(root, bg=_BG)
     btn_frame.pack(pady=4)
 
-    activate_btn = tk.Button(
-        btn_frame, text="Activate",
-        font=("Segoe UI", 10, "bold"),
-        bg=_ACCENT, fg="white",
-        activebackground="#3a7ae0", activeforeground="white",
-        relief="flat", cursor="hand2", padx=24, pady=8,
-        command=lambda: _on_activate(root, key_var, status_var, status_label,
-                                      activate_btn, activated)
-    )
-    activate_btn.grid(row=0, column=0, padx=8)
+    activate_btn = _PillBtn(btn_frame, "Activate",
+                            command=lambda: _on_activate(
+                                root, key_var, status_var, status_label,
+                                activate_btn, activated, hwid),
+                            width=130, height=38, bg=_ACCENT, fg="#000000")
+    activate_btn.grid(row=0, column=0, padx=10)
 
-    exit_btn = tk.Button(
-        btn_frame, text="Exit",
-        font=("Segoe UI", 10),
-        bg=_PANEL, fg=_SUBTEXT,
-        activebackground=_BORDER, activeforeground=_TEXT,
-        relief="flat", cursor="hand2", padx=24, pady=8,
-        command=lambda: _on_exit(root, activated)
-    )
-    exit_btn.grid(row=0, column=1, padx=8)
+    exit_btn = _PillBtn(btn_frame, "Exit",
+                        command=lambda: _on_exit(root, activated),
+                        width=110, height=38, bg=_BORDER, fg=_SUBTEXT)
+    exit_btn.grid(row=0, column=1, padx=10)
 
-    # Allow Enter key to trigger activation
     root.bind("<Return>", lambda e: _on_activate(
-        root, key_var, status_var, status_label, activate_btn, activated
-    ))
+        root, key_var, status_var, status_label, activate_btn, activated, hwid))
 
     # ---- Footer ----
-    tk.Label(
-        root, text="Need a license? Contact us to subscribe.",
-        font=("Segoe UI", 8),
-        bg=_BG, fg=_SUBTEXT
-    ).pack(side="bottom", pady=14)
+    tk.Label(root, text="Need a license? Contact us to subscribe.",
+             font=("Segoe UI", 8),
+             bg=_BG, fg=_SUBTEXT).pack(side="bottom", pady=14)
 
     root.mainloop()
     return activated[0]
 
 
-def _on_activate(root, key_var, status_var, status_label, activate_btn, activated):
+def _on_activate(root, key_var, status_var, status_label,
+                 activate_btn, activated, hwid):
     key = key_var.get().strip()
-
     if not key:
         status_var.set("Please enter a license key.")
         return
 
-    # Show checking state
-    activate_btn.config(state="disabled", text="Checking…")
+    activate_btn.set_enabled(False)
+    activate_btn.set_text("Checking…")
     status_var.set("Contacting license server…")
     status_label.config(fg=_SUBTEXT)
     root.update()
 
     try:
-        hwid   = get_hwid()
         valid, reason = license_check.verify_license(key, hwid)
     except Exception as exc:
-        activate_btn.config(state="normal", text="Activate")
+        activate_btn.set_enabled(True)
+        activate_btn.set_text("Activate")
         status_var.set(f"Error: {exc}")
         status_label.config(fg=_ERROR)
         return
@@ -158,7 +188,8 @@ def _on_activate(root, key_var, status_var, status_label, activate_btn, activate
         activated[0] = True
         root.after(900, root.destroy)
     else:
-        activate_btn.config(state="normal", text="Activate")
+        activate_btn.set_enabled(True)
+        activate_btn.set_text("Activate")
         status_var.set(reason)
         status_label.config(fg=_ERROR)
 
diff --git a/build.bat b/build.bat
index 9fd6e1e..c11cfe5 100644
--- a/build.bat
+++ b/build.bat
@@ -6,7 +6,7 @@ echo ======================================
 echo.
 
 echo Installing dependencies...
-python -m pip install pyinstaller tinyaes matplotlib --quiet
+python -m pip install pyinstaller matplotlib --quiet
 if errorlevel 1 (
     echo ERROR: pip failed. Make sure Python is installed and on PATH.
     pause
@@ -21,48 +21,12 @@ copy /Y dist\stock_screener.py stock_screener.py >nul
 echo Building executable...
 echo.
 
-python -m PyInstaller ^
-  --onefile ^
-  --windowed ^
-  --key "UIT-K3y-2025-Ultr4Inv3st" ^
-  --name "StockScreener" ^
-  --hidden-import pandas ^
-  --hidden-import numpy ^
-  --hidden-import yfinance ^
-  --hidden-import requests ^
-  --hidden-import lxml ^
-  --hidden-import lxml.etree ^
-  --hidden-import html5lib ^
-  --hidden-import bs4 ^
-  --hidden-import appdirs ^
-  --hidden-import platformdirs ^
-  --hidden-import tkinter ^
-  --hidden-import tkinter.ttk ^
-  --hidden-import tkinter.messagebox ^
-  --hidden-import screener_gui ^
-  --hidden-import stock_screener ^
-  --hidden-import matplotlib ^
-  --hidden-import matplotlib.backends.backend_tkagg ^
-  --hidden-import matplotlib.figure ^
-  --hidden-import matplotlib.dates ^
-  --hidden-import matplotlib.ticker ^
-  --hidden-import winreg ^
-  --hidden-import hwid ^
-  --hidden-import license_check ^
-  --hidden-import activation_dialog ^
-  --hidden-import updater ^
-  --collect-all yfinance ^
-  --collect-all matplotlib ^
-  launcher.py
+python -m PyInstaller StockScreener.spec
 
 if errorlevel 1 (
     echo.
     echo BUILD FAILED. See errors above.
     echo.
-    echo NOTE: If the error mentions '--key' or 'tinyaes', your PyInstaller version
-    echo       may not support bytecode encryption. Remove the '--key' line above
-    echo       and rebuild. Encryption requires PyInstaller 5.x + tinyaes.
-    echo.
     echo Cleaning up temporary files...
     if exist screener_gui.py   del screener_gui.py
     if exist stock_screener.py del stock_screener.py
diff --git a/cache_builder.py b/cache_builder.py
new file mode 100644
index 0000000..9f51ddb
--- /dev/null
+++ b/cache_builder.py
@@ -0,0 +1,320 @@
+"""
+Analyst & News Cache Builder
+============================
+Runs nightly via GitHub Actions. Fetches analyst consensus data and
+news sentiment for every US-listed stock and upserts results into the
+Supabase analyst_cache table.
+
+Phase 1 — Analyst data via yf.Ticker.info        (~50 min for 6,500 tickers)
+Phase 2 — News sentiment via Google News RSS      (~6 min, 20 workers)
+
+Each phase writes to Supabase incrementally every UPSERT_EVERY records
+so a partial run is never fully lost.
+"""
+
+import html
+import os
+import random
+import re
+import time
+import urllib.parse
+import xml.etree.ElementTree as ET
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timezone
+
+import requests
+import yfinance as yf
+
+try:
+    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+    _VADER = SentimentIntensityAnalyzer()
+except ImportError:
+    _VADER = None
+
+# ---------------------------------------------------------------------------
+# Supabase credentials — injected as GitHub Actions secrets
+# ---------------------------------------------------------------------------
+_SUPABASE_URL = os.environ["SUPABASE_URL"]
+_SUPABASE_KEY = os.environ["SUPABASE_SERVICE_KEY"]
+
+_SUPABASE_HEADERS = {
+    "apikey":        _SUPABASE_KEY,
+    "Authorization": f"Bearer {_SUPABASE_KEY}",
+    "Content-Type":  "application/json",
+    "Prefer":        "resolution=merge-duplicates",
+}
+
+# ---------------------------------------------------------------------------
+# Constants
+# ---------------------------------------------------------------------------
+_TICKER_RE    = re.compile(r'^[A-Z]{1,5}(-[A-Z]{1,2})?$')
+_HTTP_HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
+
+INFO_BATCH   = 20
+INFO_PAUSE   = 4.0
+MAX_WORKERS  = 5
+NEWS_WORKERS = 20
+UPSERT_EVERY = 500
+
+
+# ---------------------------------------------------------------------------
+# Ticker fetching (NASDAQ Trader files — same source as the screener)
+# ---------------------------------------------------------------------------
+
+def _clean_ticker(symbol: str) -> str | None:
+    t = symbol.strip().upper().replace(".", "-")
+    return t if _TICKER_RE.match(t) else None
+
+
+def fetch_tickers() -> list[str]:
+    """Return all US common-stock tickers from NASDAQ Trader listing files."""
+    tickers = []
+    base    = "https://www.nasdaqtrader.com/dynamic/SymDir/"
+
+    # NASDAQ-listed stocks
+    try:
+        resp = requests.get(base + "nasdaqlisted.txt", headers=_HTTP_HEADERS, timeout=20)
+        resp.raise_for_status()
+        for line in resp.text.splitlines()[1:]:
+            if line.startswith("File Creation"):
+                break
+            parts = line.split("|")
+            if len(parts) < 7:
+                continue
+            if parts[3].strip() == "Y" or parts[6].strip() == "Y":   # test/ETF
+                continue
+            t = _clean_ticker(parts[0].strip())
+            if t:
+                tickers.append(t)
+        print(f"  NASDAQ listed : {sum(1 for _ in tickers)} tickers")
+    except Exception as e:
+        print(f"  [WARN] nasdaqlisted.txt: {e}")
+
+    # NYSE / AMEX listed stocks
+    try:
+        resp = requests.get(base + "otherlisted.txt", headers=_HTTP_HEADERS, timeout=20)
+        resp.raise_for_status()
+        count = 0
+        for line in resp.text.splitlines()[1:]:
+            if line.startswith("File Creation"):
+                break
+            parts = line.split("|")
+            if len(parts) < 7:
+                continue
+            if parts[2].strip() not in {"N", "A"}:   # NYSE=N, AMEX=A only
+                continue
+            if parts[4].strip() == "Y" or parts[6].strip() == "Y":   # ETF/test
+                continue
+            t = _clean_ticker(parts[0].strip())
+            if t:
+                tickers.append(t)
+                count += 1
+        print(f"  NYSE/AMEX     : {count} tickers")
+    except Exception as e:
+        print(f"  [WARN] otherlisted.txt: {e}")
+
+    combined = list(dict.fromkeys(tickers))
+    print(f"  Total         : {len(combined)} unique tickers\n")
+    return combined
+
+
+# ---------------------------------------------------------------------------
+# Phase 1 — Analyst data
+# ---------------------------------------------------------------------------
+
+def _fetch_analyst(ticker: str) -> dict | None:
+    """Fetch analyst consensus fields for one ticker via yf.Ticker.info."""
+    time.sleep(random.uniform(0.0, 1.0))
+    try:
+        info = yf.Ticker(ticker).info
+        if not info or not isinstance(info, dict) or len(info) < 3:
+            return None
+
+        try:
+            rec_mean = float(info["recommendationMean"]) if info.get("recommendationMean") is not None else None
+        except (TypeError, ValueError):
+            rec_mean = None
+        analyst_norm = (5.0 - rec_mean) / 4.0 if rec_mean is not None and 1 <= rec_mean <= 5 else None
+
+        try:
+            target = float(info["targetMeanPrice"]) if info.get("targetMeanPrice") is not None else None
+        except (TypeError, ValueError):
+            target = None
+
+        price = info.get("currentPrice") or info.get("regularMarketPrice")
+        try:
+            price = float(price) if price is not None else None
+        except (TypeError, ValueError):
+            price = None
+
+        analyst_upside = (target / price - 1.0) if target and price and price > 0 else None
+
+        return {
+            "ticker":         ticker,
+            "pe_forward":     info.get("forwardPE"),
+            "eps_forward":    info.get("forwardEps"),
+            "analyst_norm":   analyst_norm,
+            "analyst_upside": analyst_upside,
+            "analyst_count":  info.get("numberOfAnalystOpinions"),
+            "analyst_target": target,
+            "recommendation": info.get("recommendationKey") or "N/A",
+            "sector":         info.get("sector")   or None,
+            "industry":       info.get("industry") or None,
+            "updated_at":     datetime.now(timezone.utc).isoformat(),
+        }
+    except Exception:
+        return None
+
+
+def run_analyst_phase(tickers: list[str]) -> None:
+    print(f"Phase 1: Analyst data for {len(tickers)} tickers ...")
+    total   = len(tickers)
+    done    = 0
+    pending: list[dict] = []
+    start   = time.time()
+
+    for batch_start in range(0, total, INFO_BATCH):
+        batch = tickers[batch_start: batch_start + INFO_BATCH]
+        with ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+            futures = {ex.submit(_fetch_analyst, t): t for t in batch}
+            for fut in as_completed(futures):
+                done += 1
+                result = fut.result()
+                if result:
+                    pending.append(result)
+                elapsed = time.time() - start
+                eta     = (elapsed / done) * (total - done) if done else 0
+                print(
+                    f"\r  {done}/{total} ({done / total * 100:.0f}%)"
+                    f"  cached={len(pending)}  ETA={eta:.0f}s   ",
+                    end="", flush=True,
+                )
+
+        if len(pending) >= UPSERT_EVERY:
+            print()
+            _upsert(pending)
+            pending.clear()
+
+        if batch_start + INFO_BATCH < total:
+            time.sleep(INFO_PAUSE)
+
+    if pending:
+        print()
+        _upsert(pending)
+
+    print(f"\n  Phase 1 complete in {time.time() - start:.0f}s\n")
+
+
+# ---------------------------------------------------------------------------
+# Phase 2 — News sentiment (Google News RSS + VADER)
+# ---------------------------------------------------------------------------
+
+def _fetch_news_sentiment(ticker: str) -> dict | None:
+    """Fetch Google News RSS headlines and compute VADER compound score."""
+    if _VADER is None:
+        return None
+    try:
+        query   = urllib.parse.quote(f"{ticker} stock")
+        rss_url = (
+            f"https://news.google.com/rss/search"
+            f"?q={query}&hl=en-US&gl=US&ceid=US:en"
+        )
+        resp = requests.get(rss_url, headers=_HTTP_HEADERS, timeout=8)
+        resp.raise_for_status()
+        root   = ET.fromstring(resp.content)
+        scores = []
+        for item in root.findall(".//item")[:15]:
+            title_el = item.find("title")
+            if title_el is not None and title_el.text:
+                title = html.unescape(
+                    re.sub(r"<[^>]+>", " ", title_el.text)
+                ).strip()
+                scores.append(_VADER.polarity_scores(title)["compound"])
+        sentiment = sum(scores) / len(scores) if scores else None
+        return {
+            "ticker":         ticker,
+            "news_sentiment": sentiment,
+            "updated_at":     datetime.now(timezone.utc).isoformat(),
+        }
+    except Exception:
+        return None
+
+
+def run_news_phase(tickers: list[str]) -> None:
+    if _VADER is None:
+        print("Phase 2: Skipped — vaderSentiment not installed\n")
+        return
+
+    print(f"Phase 2: News sentiment for {len(tickers)} tickers ...")
+    total   = len(tickers)
+    done    = 0
+    pending: list[dict] = []
+    start   = time.time()
+
+    with ThreadPoolExecutor(max_workers=NEWS_WORKERS) as ex:
+        futures = {ex.submit(_fetch_news_sentiment, t): t for t in tickers}
+        for fut in as_completed(futures):
+            done += 1
+            result = fut.result()
+            if result:
+                pending.append(result)
+            if done % 200 == 0:
+                elapsed = time.time() - start
+                eta     = (elapsed / done) * (total - done) if done else 0
+                print(
+                    f"\r  {done}/{total} ({done / total * 100:.0f}%)"
+                    f"  ETA={eta:.0f}s   ",
+                    end="", flush=True,
+                )
+            if len(pending) >= UPSERT_EVERY:
+                _upsert(pending)
+                pending.clear()
+
+    if pending:
+        _upsert(pending)
+
+    print(f"\n  Phase 2 complete in {time.time() - start:.0f}s\n")
+
+
+# ---------------------------------------------------------------------------
+# Supabase upsert
+# ---------------------------------------------------------------------------
+
+def _upsert(rows: list[dict]) -> None:
+    """Upsert a batch of rows into analyst_cache (merge on primary key)."""
+    if not rows:
+        return
+    try:
+        resp = requests.post(
+            f"{_SUPABASE_URL}/rest/v1/analyst_cache",
+            headers=_SUPABASE_HEADERS,
+            json=rows,
+            timeout=30,
+        )
+        resp.raise_for_status()
+        print(f"  Upserted {len(rows)} rows to Supabase")
+    except Exception as e:
+        print(f"  [WARN] Upsert failed: {e}")
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    print("=" * 55)
+    print("  ANALYST + NEWS CACHE BUILDER")
+    print("=" * 55 + "\n")
+
+    tickers = fetch_tickers()
+    if not tickers:
+        print("ERROR: No tickers fetched — aborting.")
+        raise SystemExit(1)
+
+    run_analyst_phase(tickers)
+    run_news_phase(tickers)
+    print("Cache build complete.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/dist/screener_gui.py b/dist/screener_gui.py
new file mode 100644
index 0000000..02c1b48
--- /dev/null
+++ b/dist/screener_gui.py
@@ -0,0 +1,5011 @@
+"""
+Ultimate Investment Tool GUI
+============================
+Graphical interface for the multi-factor stock screener.
+
+Run:       python screener_gui.py
+Build exe: build.bat
+"""
+
+import ctypes
+import html as _html
+import io
+import multiprocessing
+import queue
+import re
+import sys
+import threading
+import tkinter as tk
+import webbrowser
+from tkinter import ttk
+
+import numpy as np
+
+_MATPLOTLIB_OK = False
+_MATPLOTLIB_ERR = ""
+try:
+    import matplotlib
+    matplotlib.use("TkAgg")
+    import matplotlib.ticker as mticker
+    from matplotlib.figure import Figure
+    from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
+    import matplotlib.dates as mdates
+    _MATPLOTLIB_OK = True
+except Exception as _e:
+    _MATPLOTLIB_ERR = str(_e)
+
+_YF_OK = False
+try:
+    import yfinance as yf
+    _YF_OK = True
+except Exception:
+    pass
+
+from stock_screener import (INDEX_CHOICES, STRATEGY_PRESETS, WEIGHTS,
+                            collect_tickers, fetch_all, score_stocks,
+                            get_news_headlines, fetch_insider_trades)
+
+# Short descriptions shown as tooltips when hovering strategy dropdown items
+STRATEGY_DESCRIPTIONS = {
+    "Balanced (Default)": (
+        "Best for: General all-purpose screening.\n\n"
+        "Blends all 8 factors evenly — no strong directional bias. "
+        "Good starting point for building a diversified watch list."
+    ),
+    "High Growth Companies": (
+        "Best for: High-velocity growth investing.\n\n"
+        "Heavily weights revenue/earnings growth (28%) and price momentum (25%). "
+        "Targets fast-growing tech, biotech, and SaaS. "
+        "Higher risk — low weight on value and safety metrics."
+    ),
+    "Conservative": (
+        "Best for: Capital preservation and low volatility.\n\n"
+        "Prioritises balance sheet quality (25%) and profitability (18%). "
+        "Targets blue-chip companies with low debt and stable earnings."
+    ),
+    "Recent Uptrends": (
+        "Best for: Short-term technical trend-following.\n\n"
+        "Momentum dominates at 40% — driven by 6-month price return. "
+        "News sentiment adds 18%. Valuation nearly irrelevant. "
+        "Best used in bull markets with high portfolio turnover."
+    ),
+    "Buy and Hold Long Term": (
+        "Best for: Value-focused buy-and-hold investors.\n\n"
+        "Screens for deeply undervalued stocks by P/E, P/B, and EV/EBITDA (30%). "
+        "Risk factor ignored — long holding period absorbs volatility. "
+        "Classic fundamental investing approach."
+    ),
+    "Low Risk, High Dividend Yield": (
+        "Best for: Income-focused portfolios seeking stable cash flow.\n\n"
+        "Profitability (28%) and quality (22%) dominate. Targets mature companies "
+        "converting revenue to free cash flow reliably. Suitable for retirees."
+    ),
+    "High Risk High Reward": (
+        "Best for: Contrarian bounce plays on oversold names.\n\n"
+        "Reverse momentum (35%) rewards beaten-down stocks. Analyst upside (30%) "
+        "filters for institutional conviction. Quality floor (15%) avoids value traps."
+    ),
+    "Custom...": (
+        "Define your own strategy.\n\n"
+        "Set custom weights for each of the 8 scoring factors. "
+        "Click to open the configuration dialog."
+    ),
+}
+
+multiprocessing.freeze_support()
+
+# Read update channel from license cache (set during auth in launcher.py)
+try:
+    import license_check as _lc
+    _CHANNEL = _lc.get_channel()
+except Exception:
+    _CHANNEL = "stable"
+
+try:
+    from updater import APP_VERSION as _APP_VERSION
+except Exception:
+    _APP_VERSION = "?"
+
+_APP_NAME = "Ultimate Investment Tool"
+_channel_label = "Beta" if _CHANNEL == "beta" else "Stable"
+_WINDOW_TITLE = f"{_APP_NAME} v{_APP_VERSION} — {_channel_label}"
+
+# Tell Windows the process handles its own DPI scaling (crisp rendering).
+try:
+    ctypes.windll.shcore.SetProcessDpiAwareness(2)   # per-monitor DPI aware
+except Exception:
+    try:
+        ctypes.windll.shcore.SetProcessDpiAwareness(1)
+    except Exception:
+        try:
+            ctypes.windll.user32.SetProcessDPIAware()
+        except Exception:
+            pass
+
+# ---------------------------------------------------------------------------
+# DPI scaling — computed HERE at module load via the Windows GDI API,
+# BEFORE any Tk window is created.
+#
+# Why not winfo_fpixels()?  That call requires a visible window that has
+# been assigned to a monitor.  When called immediately after Tk() in
+# __init__, the window is still hidden/off-screen, so Windows reports the
+# primary monitor DPI — which may differ from the monitor the maximised
+# window actually lands on.  GetDeviceCaps on the screen DC is always
+# consistent and works before any window exists.
+#
+# _S  : scale factor (actual PPI / 96).  1.0 at 100%, 1.25 at 125%, etc.
+# _s(n): scale any hard-coded pixel value for the current display DPI.
+# ---------------------------------------------------------------------------
+_S: float = 1.0
+try:
+    _hdc = ctypes.windll.user32.GetDC(0)          # 0 = screen DC
+    _dpi = ctypes.windll.gdi32.GetDeviceCaps(_hdc, 88)  # LOGPIXELSX = 88
+    ctypes.windll.user32.ReleaseDC(0, _hdc)
+    if _dpi > 0:
+        _S = _dpi / 96.0
+except Exception:
+    _S = 1.0
+
+def _s(n: float) -> int:
+    """Return n scaled to the current display DPI (minimum 1 pixel)."""
+    return max(1, int(n * _S))
+
+# ---------------------------------------------------------------------------
+# Sector filter  (display name → (dataframe column, exact value to match))
+# None means "no filter" (show all sectors).
+# Defense is a sub-industry inside Industrials, so it filters on "industry".
+# ---------------------------------------------------------------------------
+
+_SECTOR_FILTER_MAP = {
+    "All Sectors":       None,
+    "Technology":        ("sector",   "Technology"),
+    "Healthcare":        ("sector",   "Healthcare"),
+    "Financials":        ("sector",   "Financial Services"),
+    "Consumer Disc.":    ("sector",   "Consumer Cyclical"),
+    "Consumer Staples":  ("sector",   "Consumer Defensive"),
+    "Industrials":       ("sector",   "Industrials"),
+    "Defense":           ("industry", "Aerospace & Defense"),
+    "Energy":            ("sector",   "Energy"),
+    "Materials":         ("sector",   "Basic Materials"),
+    "Real Estate":       ("sector",   "Real Estate"),
+    "Communication":     ("sector",   "Communication Services"),
+    "Utilities":         ("sector",   "Utilities"),
+}
+
+SECTOR_CHOICES = list(_SECTOR_FILTER_MAP.keys())
+
+
+# ---------------------------------------------------------------------------
+# Theme
+# ---------------------------------------------------------------------------
+
+T = {
+    "bg":         "#000000",   # pure black — main background
+    "bg2":        "#000000",   # same black — seamless panels
+    "bg3":        "#0d0d0d",   # near-black — barely raised surfaces
+    "border":     "#0d0d0d",   # near-invisible — seamless separators
+    "fg":         "#ffffff",   # white — primary text
+    "fg2":        "#555555",   # gray — secondary / dim text
+    "accent":     "#00e676",   # bright green — primary accent
+    "green":      "#00e676",   # green — positive indicators
+    "red":        "#ff4545",   # red — negative indicators
+    "yellow":     "#ffd740",   # amber — neutral indicators
+    "sel":        "#00261a",   # dark green — selection highlight
+    "row_odd":    "#040404",   # near-black row stripe
+    "row_even":   "#000000",   # pure black row stripe
+    "font_ui":    ("Segoe UI", 11),
+    "font_mono":  ("Consolas", 11),
+    "font_head":  ("Segoe UI", 12, "bold"),
+    "font_sec":   ("Segoe UI", 10, "bold"),
+    "font_small": ("Segoe UI", 10),
+}
+
+
+# ---------------------------------------------------------------------------
+# Stdout redirector
+# ---------------------------------------------------------------------------
+
+_PROGRESS_RE = re.compile(
+    r"(\d+)/(\d+).*?ok=(\d+).*?skip=(\d+).*?ETA=(\d+(?:\.\d+)?)"
+)
+# Matches new fetch_all Phase-1 output: "  123/456 scanned  valid=89  (27%)"
+_PHASE1_RE = re.compile(r"(\d+)/(\d+)\s+scanned\s+valid=(\d+)")
+
+
+class _StdoutRedirector(io.TextIOBase):
+    def __init__(self, q: queue.Queue, run_id: int = 0):
+        self._q = q
+        self._run_id = run_id
+
+    def write(self, s: str) -> int:
+        if not s or not s.strip():
+            return len(s) if s else 0
+        m = _PROGRESS_RE.search(s)
+        if m:
+            done, total, ok, skip, eta = m.groups()
+            self._q.put({"type": "progress", "run_id": self._run_id,
+                         "done": int(done), "total": int(total),
+                         "ok": int(ok), "skip": int(skip), "eta": float(eta)})
+        else:
+            # Match Phase-1 price-history progress: "N/N scanned  valid=V  (X%)"
+            m2 = _PHASE1_RE.search(s)
+            if m2:
+                done, total, ok = m2.groups()
+                self._q.put({"type": "progress", "run_id": self._run_id,
+                             "done": int(done), "total": int(total),
+                             "ok": int(ok), "skip": 0, "eta": 0.0})
+            else:
+                self._q.put({"type": "status", "run_id": self._run_id,
+                             "text": s.strip()})
+        return len(s)
+
+    def flush(self):
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Formatters
+# ---------------------------------------------------------------------------
+
+def _nan(v):
+    return v is None or (isinstance(v, float) and np.isnan(v))
+
+def _pct(v):
+    return "—" if _nan(v) else f"{v * 100:.1f}%"
+
+def _flt(v, d=2):
+    return "—" if _nan(v) else f"{v:.{d}f}"
+
+def _price(v):
+    return "—" if _nan(v) else f"${v:,.2f}"
+
+def _mcap(v):
+    if _nan(v): return "—"
+    if v >= 1e12: return f"${v / 1e12:.2f}T"
+    if v >= 1e9:  return f"${v / 1e9:.2f}B"
+    if v >= 1e6:  return f"${v / 1e6:.2f}M"
+    return f"${v:.0f}"
+
+def _score(v):
+    return "—" if _nan(v) else f"{v:.1f}"
+
+def _fmt_shares(v):
+    """Format a share count with commas; returns '—' for None."""
+    if v is None: return "—"
+    return f"{int(v):,}"
+
+def _fmt_value(v):
+    """Format a dollar value compactly: $1.2M, $340K, etc."""
+    if v is None: return "—"
+    if v >= 1e9: return f"${v / 1e9:.1f}B"
+    if v >= 1e6: return f"${v / 1e6:.1f}M"
+    if v >= 1e3: return f"${v / 1e3:.0f}K"
+    return f"${v:.0f}"
+
+
+# ---------------------------------------------------------------------------
+# Tooltip
+# ---------------------------------------------------------------------------
+
+class _Tooltip:
+    """
+    Attaches a dark-themed popup to a tk.Label.
+
+    Strategy:
+    - <Enter>  → always show immediately (reliable trigger).
+    - <Motion> → hide if the cursor has drifted outside the text bounding
+                 box (padding area), so the popup disappears the moment the
+                 cursor leaves the actual characters.
+    - <Leave>  → hide when the cursor leaves the widget entirely.
+
+    font, padx, pady, anchor are passed explicitly at construction time so
+    no fragile runtime widget inspection is needed.
+    """
+    _PAD = 8
+
+    def __init__(self, widget: tk.Widget, text: str,
+                 font=None, padx: int = 0, pady: int = 0,
+                 anchor: str = "center"):
+        self._w         = widget
+        self._text      = text.strip()
+        self._tip: tk.Toplevel | None = None
+        self._padx      = padx
+        self._pady      = pady
+        self._anchor    = anchor
+        self._font_spec = font          # kept as a tuple for tk.call font commands
+        widget.bind("<Enter>",  self._show,      add="+")
+        widget.bind("<Motion>", self._on_motion, add="+")
+        widget.bind("<Leave>",  self._hide,      add="+")
+        widget.bind("<Button>", self._hide,      add="+")
+
+    def _text_bbox(self) -> tuple[int, int, int, int]:
+        """(x1, y1, x2, y2) of the rendered text inside the widget.
+        Uses Tk's built-in 'font measure' / 'font metrics' so no Python
+        tkinter.font module is required (safe in frozen .exe builds)."""
+        w = self._w
+        ww, wh = w.winfo_width(), w.winfo_height()
+        if self._font_spec is None or ww <= 1:
+            return 0, 0, ww, wh          # fallback: accept full widget
+        try:
+            txt = w.cget("text")
+            tw  = int(w.tk.call("font", "measure",  self._font_spec, txt))
+            th  = int(w.tk.call("font", "metrics",  self._font_spec, "-linespace"))
+            if   self._anchor in ("w", "nw", "sw"): x1 = self._padx
+            elif self._anchor in ("e", "ne", "se"): x1 = ww - self._padx - tw
+            else:                                   x1 = (ww - tw) // 2
+            if   self._anchor in ("n", "nw", "ne"): y1 = self._pady
+            elif self._anchor in ("s", "sw", "se"): y1 = wh - self._pady - th
+            else:                                   y1 = (wh - th) // 2
+            return x1, y1, x1 + tw, y1 + th
+        except Exception:
+            return 0, 0, ww, wh
+
+    def _on_motion(self, event):
+        x1, y1, x2, y2 = self._text_bbox()
+        if not (x1 <= event.x <= x2 and y1 <= event.y <= y2):
+            self._hide()
+
+    def _show(self, _event=None):
+        if self._tip or not self._text:
+            return
+        x = self._w.winfo_rootx() + self._PAD
+        y = self._w.winfo_rooty() + self._w.winfo_height() + 4
+        self._tip = tw = tk.Toplevel(self._w)
+        tw.wm_overrideredirect(True)
+        tw.wm_attributes("-topmost", True)
+        tw.wm_geometry(f"+{x}+{y}")
+        tw.configure(bg=T["bg3"])
+        tk.Label(
+            tw, text=self._text,
+            bg=T["bg3"], fg=T["fg"],
+            font=("Segoe UI", 9),
+            justify="left", wraplength=340,
+            padx=12, pady=8,
+        ).pack()
+
+    def _hide(self, _event=None):
+        if self._tip:
+            self._tip.destroy()
+            self._tip = None
+
+
+# ---------------------------------------------------------------------------
+# Metric tooltip text  (keyed by the display label shown in the detail panel)
+# ---------------------------------------------------------------------------
+
+_METRIC_TOOLTIPS: dict[str, str] = {
+    # ── Scores ──────────────────────────────────────────────────────────────
+    "Composite Score": (
+        "The overall investment attractiveness of the stock, scored 0–100.\n\n"
+        "Calculated as a weighted blend of all 8 factor scores — Value, Growth,\n"
+        "Momentum, Quality, Profitability, Sentiment, Analyst, and Risk.\n\n"
+        "The weights shift based on your selected strategy, so the same stock\n"
+        "can score differently under Growth vs. Conservative, for example.\n"
+        "A higher score means the stock looks more attractive across the\n"
+        "factors that matter most to your chosen investment approach."
+    ),
+    "Value": (
+        "How cheaply the stock is priced relative to what the company earns,\n"
+        "owns, and generates — scored 0–100.\n\n"
+        "A high Value score means the market is pricing the stock at a discount\n"
+        "compared to its earnings power and asset base. This can signal an\n"
+        "undervalued opportunity, though cheap stocks can stay cheap.\n\n"
+        "Calculated by blending three valuation ratios: how much investors\n"
+        "pay per dollar of earnings (P/E), per dollar of book assets (P/B),\n"
+        "and per dollar of operating profit including debt (EV/EBITDA)."
+    ),
+    "Growth": (
+        "How fast the company is expanding its business — scored 0–100.\n\n"
+        "A high Growth score means the company is meaningfully growing its\n"
+        "revenue and profits year over year, and analysts expect that trend\n"
+        "to continue. Strong growth justifies higher valuations and often\n"
+        "drives long-term stock price appreciation.\n\n"
+        "Calculated by combining year-over-year revenue growth, earnings\n"
+        "growth, and the gap between analysts' future EPS estimates and\n"
+        "the company's most recent actual earnings."
+    ),
+    "Momentum": (
+        "How strong the stock's recent price trend has been — scored 0–100.\n\n"
+        "Stocks that have risen steadily tend to keep rising in the near term,\n"
+        "a well-documented market pattern. A high Momentum score means the\n"
+        "stock has outperformed over recent months, which can reflect growing\n"
+        "investor confidence or improving fundamentals.\n\n"
+        "Calculated by measuring total price returns over four time windows\n"
+        "(1, 3, 6, and 12 months), with the 6-month window weighted most\n"
+        "heavily as it is historically the most predictive."
+    ),
+    "Quality": (
+        "How financially sound and efficiently run the company is — scored 0–100.\n\n"
+        "A high Quality score means the company earns strong returns on its\n"
+        "capital, carries manageable debt, and has enough liquid assets to\n"
+        "cover near-term obligations. High-quality businesses tend to be more\n"
+        "resilient during downturns.\n\n"
+        "Calculated from four balance-sheet metrics: return on equity, return\n"
+        "on assets, debt-to-equity ratio, and current ratio."
+    ),
+    "Profitability": (
+        "How much of its revenue the company actually keeps as profit — scored 0–100.\n\n"
+        "A highly profitable business earns wide margins and converts sales into\n"
+        "real cash. This is a sign of pricing power and operational efficiency,\n"
+        "and companies with strong profitability can self-fund growth without\n"
+        "relying on debt or dilutive share issuance.\n\n"
+        "Calculated by blending net profit margin, operating margin, and free\n"
+        "cash flow yield (how much cash the business generates relative to\n"
+        "its market value)."
+    ),
+    "Sentiment": (
+        "The overall tone of recent news coverage about the company — scored 0–100.\n\n"
+        "Positive news flow often reflects improving business conditions or\n"
+        "favorable market perception, while negative sentiment can signal\n"
+        "headwinds. This score captures the market narrative around a stock\n"
+        "that may not yet show up in financial statements.\n\n"
+        "Calculated by running recent headlines through an AI language model\n"
+        "that rates each article from strongly negative to strongly positive.\n"
+        "Older articles carry less weight than recent ones."
+    ),
+    "Analyst": (
+        "How bullish professional analysts are on the stock — scored 0–100.\n\n"
+        "Institutional analysts spend significant time modeling companies and\n"
+        "meeting with management. A high Analyst score means the consensus\n"
+        "view is favorable: analysts rate it a Buy (or better) and their\n"
+        "average price target sits meaningfully above the current price.\n\n"
+        "Calculated from three inputs: the consensus buy/sell recommendation,\n"
+        "the percentage upside implied by the average price target, and the\n"
+        "number of analysts actively covering the stock."
+    ),
+    "Risk": (
+        "How low-risk the stock appears — scored 0–100, where higher = safer.\n\n"
+        "This score is inverted: a high Risk score means the stock carries\n"
+        "relatively low risk. Risk here captures how much professional short\n"
+        "sellers are betting against it, how erratically the price moves\n"
+        "day to day, and how closely its swings track the broader market.\n\n"
+        "Calculated from short interest as a share of the float, 30-day\n"
+        "realized price volatility, and how far the stock's beta deviates\n"
+        "from 1.0 (the market average)."
+    ),
+
+    # ── Valuation ───────────────────────────────────────────────────────────
+    "Price": (
+        "The most recent closing market price of the stock in USD.\n\n"
+        "This is the price at which the stock last traded on the exchange.\n"
+        "It is used as the basis for all valuation ratios shown in this panel."
+    ),
+    "Market Cap": (
+        "The total market value of the company — share price multiplied by\n"
+        "the total number of shares outstanding.\n\n"
+        "Market cap is the most widely used measure of company size. It tells\n"
+        "you how much the market currently thinks the entire business is worth."
+    ),
+    "P/E Forward": (
+        "How much investors are paying per dollar of the company's expected\n"
+        "future earnings over the next 12 months.\n\n"
+        "A lower forward P/E generally means the stock is cheaper relative to\n"
+        "where analysts expect profits to go. It is calculated by dividing the\n"
+        "current stock price by the analyst consensus EPS estimate for the\n"
+        "coming year. Missing or negative when a loss is expected."
+    ),
+    "P/E Trailing": (
+        "How much investors are paying per dollar of the company's actual\n"
+        "earnings over the past 12 months.\n\n"
+        "A lower trailing P/E suggests the stock is cheaper relative to what\n"
+        "it has already earned. It is calculated by dividing the current price\n"
+        "by actual reported earnings per share. Missing or negative when the\n"
+        "company posted a net loss."
+    ),
+    "P/B Ratio": (
+        "How much investors are paying relative to the company's net asset value\n"
+        "as recorded on its balance sheet.\n\n"
+        "A ratio below 1.0 means the stock trades at less than the accounting\n"
+        "value of its assets minus liabilities — potentially a deep value signal.\n"
+        "Calculated by dividing the share price by book value per share."
+    ),
+    "EV / EBITDA": (
+        "A valuation ratio that compares the company's total value — including\n"
+        "its debt — to its operating earnings before non-cash charges.\n\n"
+        "Because it accounts for debt, it is useful for comparing companies\n"
+        "with different capital structures. A lower ratio generally indicates\n"
+        "a cheaper business. Enterprise Value is market cap plus net debt;\n"
+        "EBITDA strips out interest, taxes, and depreciation."
+    ),
+    "52W High": (
+        "The highest price the stock reached over the past 52 weeks.\n\n"
+        "Often used as a reference point for resistance. A stock trading far\n"
+        "below its 52-week high may be recovering from a selloff, while one\n"
+        "near its high may signal ongoing strength or potential overbought conditions."
+    ),
+    "52W Low": (
+        "The lowest price the stock reached over the past 52 weeks.\n\n"
+        "Often used as a reference point for support. A stock trading near its\n"
+        "52-week low may be deeply out of favor — a potential value opportunity\n"
+        "or a sign of deteriorating fundamentals, depending on the context."
+    ),
+    "Book Value": (
+        "The per-share net worth of the company as recorded on its balance sheet —\n"
+        "total assets minus total liabilities, divided by shares outstanding.\n\n"
+        "Book value represents what shareholders would theoretically receive\n"
+        "if the company were liquidated at accounting values. Comparing book\n"
+        "value to the share price gives the P/B ratio."
+    ),
+
+    # ── Growth ──────────────────────────────────────────────────────────────
+    "Revenue Growth": (
+        "How much the company's total sales grew compared to the same period\n"
+        "a year ago, expressed as a percentage.\n\n"
+        "Revenue growth is the top-line measure of business expansion. Sustained\n"
+        "positive growth indicates the company is winning more customers or\n"
+        "selling more product, which is a key driver of long-term value creation."
+    ),
+    "Earnings Growth": (
+        "How much the company's net profit grew compared to a year ago,\n"
+        "expressed as a percentage.\n\n"
+        "Earnings growth measures whether the bottom line is improving alongside\n"
+        "revenue. A company can grow revenue while earnings shrink if costs rise\n"
+        "faster — so earnings growth is the more important profitability signal."
+    ),
+    "EPS Forward": (
+        "The analyst consensus estimate for earnings per share over the next\n"
+        "12 months.\n\n"
+        "Forward EPS reflects where Wall Street expects the company's profitability\n"
+        "to go. A rising forward EPS relative to trailing EPS signals that analysts\n"
+        "expect the business to become more profitable."
+    ),
+    "EPS Trailing": (
+        "The actual earnings per share the company reported over the past\n"
+        "12 months (trailing twelve months).\n\n"
+        "This is a backward-looking measure of profitability. It anchors the\n"
+        "trailing P/E ratio and is compared to Forward EPS to assess whether\n"
+        "analysts expect earnings to accelerate or decline."
+    ),
+
+    # ── Momentum ────────────────────────────────────────────────────────────
+    "1-Month Return": (
+        "The stock's total price return over approximately the past month.\n\n"
+        "This is the shortest lookback window and captures very recent price\n"
+        "action. It can be noisy but is useful for spotting sudden shifts in\n"
+        "market sentiment. It carries a small weight in the Momentum score."
+    ),
+    "3-Month Return": (
+        "The stock's total price return over approximately the past three months.\n\n"
+        "A medium-term signal that smooths out short-term noise while still\n"
+        "capturing recent trends. Strong 3-month returns often reflect improving\n"
+        "fundamentals or a change in investor sentiment."
+    ),
+    "6-Month Return": (
+        "The stock's total price return over approximately the past six months.\n\n"
+        "This is the most heavily weighted momentum window because research\n"
+        "consistently shows that 6-month returns are the most predictive of\n"
+        "near-term future performance. A strong 6-month return suggests the\n"
+        "stock has durable buying interest behind it."
+    ),
+    "12-Month Return": (
+        "The stock's total price return over approximately the past year.\n\n"
+        "A long-term momentum signal that confirms sustained directional strength.\n"
+        "Stocks with strong 12-month returns have demonstrated lasting investor\n"
+        "conviction. This window helps distinguish true momentum from brief spikes."
+    ),
+
+    # ── Quality & Profit ────────────────────────────────────────────────────
+    "ROE": (
+        "Return on Equity — how much profit the company generates for every\n"
+        "dollar of shareholders' equity.\n\n"
+        "A high ROE means management is efficiently deploying the capital that\n"
+        "shareholders have invested. It is a core measure of business quality\n"
+        "and competitive advantage. Calculated as net income divided by\n"
+        "total shareholders' equity."
+    ),
+    "ROA": (
+        "Return on Assets — how much profit the company generates for every\n"
+        "dollar of total assets it holds.\n\n"
+        "ROA measures how efficiently a company uses everything it owns —\n"
+        "factories, inventory, cash — to produce earnings. A higher ROA\n"
+        "indicates a more asset-efficient, capital-light business. Calculated\n"
+        "as net income divided by total assets."
+    ),
+    "Revenue": (
+        "Total revenue earned by the company over the trailing twelve months.\n\n"
+        "Revenue is the top-line figure — the total amount billed to customers\n"
+        "before any costs are subtracted. It shows the scale of the business\n"
+        "and is the starting point for measuring profitability."
+    ),
+    "Net Income": (
+        "The company's bottom-line profit over the trailing twelve months —\n"
+        "what remains after all expenses, interest, and taxes are paid.\n\n"
+        "Net income is the most direct measure of overall profitability. A\n"
+        "growing net income means the business is becoming more profitable,\n"
+        "while a shrinking or negative figure signals financial pressure.\n"
+        "Derived from revenue multiplied by the net profit margin."
+    ),
+    "Operating Income": (
+        "Profit from the company's core business operations over the trailing\n"
+        "twelve months, before interest payments and taxes are applied.\n\n"
+        "Operating income strips out the effects of how the company is financed\n"
+        "and its tax situation, making it a cleaner view of whether the\n"
+        "underlying business is profitable. Derived from revenue multiplied\n"
+        "by the operating margin."
+    ),
+    "Total Debt": (
+        "The total amount the company owes to creditors — both short-term\n"
+        "obligations due within a year and long-term borrowings.\n\n"
+        "High debt amplifies risk: it must be serviced regardless of business\n"
+        "conditions and limits financial flexibility. Comparing total debt\n"
+        "to cash and equity gives a sense of leverage and solvency."
+    ),
+    "Total Equity": (
+        "The total book value belonging to shareholders — what the company\n"
+        "owns minus what it owes, expressed in dollar terms.\n\n"
+        "Equity represents the cumulative net assets built up by the business\n"
+        "over time. It is the denominator in ROE and a key measure of the\n"
+        "financial cushion available to absorb losses."
+    ),
+    "Total Cash": (
+        "The total cash and short-term liquid investments held by the company.\n\n"
+        "A strong cash position gives the company flexibility to invest, acquire,\n"
+        "pay dividends, or weather downturns without needing to borrow. When\n"
+        "cash exceeds total debt, the company is in a net-cash position —\n"
+        "a sign of financial strength."
+    ),
+    "Current Ratio": (
+        "A measure of short-term financial health — how easily the company\n"
+        "can cover its near-term obligations with its liquid assets.\n\n"
+        "A ratio above 2.0 is generally considered strong; below 1.0 means\n"
+        "current liabilities exceed current assets, which can signal liquidity\n"
+        "risk. Calculated by dividing current assets by current liabilities."
+    ),
+    "Profit Margin": (
+        "The percentage of revenue that the company keeps as net profit\n"
+        "after all expenses.\n\n"
+        "A higher profit margin means the company is more efficient at\n"
+        "converting sales into earnings. Wide margins often reflect pricing\n"
+        "power, scale advantages, or a differentiated product. Calculated\n"
+        "as net income divided by total revenue."
+    ),
+    "Operating Margin": (
+        "The percentage of revenue that remains as profit from core operations,\n"
+        "before interest and taxes are factored in.\n\n"
+        "Operating margin isolates how profitable the actual business is,\n"
+        "independent of how it is financed or taxed. It is a key indicator\n"
+        "of operational efficiency and pricing power. Calculated as operating\n"
+        "income divided by total revenue."
+    ),
+    "FCF Yield": (
+        "How much free cash the company generates relative to its market value,\n"
+        "expressed as a percentage.\n\n"
+        "Free cash flow is what's left after the company pays its operating\n"
+        "costs and capital expenditures — the cash it can use to pay dividends,\n"
+        "buy back shares, reduce debt, or reinvest. A high FCF yield means\n"
+        "you're getting a lot of real cash generation for the price you pay."
+    ),
+    "Dividend Yield": (
+        "The annual dividend payment per share as a percentage of the current\n"
+        "stock price.\n\n"
+        "Dividend yield represents the income return you receive just from\n"
+        "holding the stock, separate from any price appreciation. Higher yields\n"
+        "can be attractive for income-focused investors, but a very high yield\n"
+        "may sometimes signal that the market doubts the dividend's sustainability."
+    ),
+
+    # ── Analyst ─────────────────────────────────────────────────────────────
+    "Recommendation": (
+        "The aggregated buy/sell opinion of all professional analysts currently\n"
+        "covering the stock.\n\n"
+        "Analysts at investment banks and research firms rate stocks on a scale\n"
+        "from Strong Buy to Strong Sell based on in-depth financial modeling\n"
+        "and company access. The consensus shown here blends all active ratings\n"
+        "into a single summary view."
+    ),
+    "# Analysts": (
+        "The number of professional analysts actively covering this stock with\n"
+        "ratings and/or price targets.\n\n"
+        "More analyst coverage generally means higher institutional interest\n"
+        "and greater confidence in the consensus view. A stock covered by\n"
+        "30+ analysts has a well-formed market opinion; one covered by only\n"
+        "1–2 analysts carries more uncertainty in the consensus."
+    ),
+    "Price Target": (
+        "The average 12-month price target set by all analysts currently\n"
+        "covering the stock.\n\n"
+        "Each analyst publishes a target price representing where they think\n"
+        "the stock will trade in roughly one year. The figure shown here is\n"
+        "the mean of all active targets. Compare it to the current price\n"
+        "to see the implied upside or downside."
+    ),
+    "Upside to Target": (
+        "The percentage gain implied by the analyst consensus price target\n"
+        "relative to the current share price.\n\n"
+        "A positive number means analysts collectively expect the stock to\n"
+        "appreciate from here; a negative number means their target is below\n"
+        "the current price. This is one of the strongest inputs into the\n"
+        "Analyst score."
+    ),
+    "News Sentiment": (
+        "A summary score of how positive or negative recent news coverage\n"
+        "about the company has been, ranging from −1 (very negative) to +1.\n\n"
+        "Recent headlines are analyzed by an AI language model that assigns\n"
+        "each article a sentiment score based on tone and word choice. Older\n"
+        "articles are weighted less than recent ones. The final number reflects\n"
+        "the overall media narrative around the stock right now."
+    ),
+    "Short Interest": (
+        "The percentage of the stock's freely tradable shares that are currently\n"
+        "sold short by investors betting the price will fall.\n\n"
+        "High short interest (above 10% of the float) signals significant\n"
+        "institutional skepticism about the company's prospects. It can also\n"
+        "set up a short squeeze if the stock rallies and short sellers rush\n"
+        "to cover their positions."
+    ),
+    "Beta": (
+        "A measure of how much the stock tends to move relative to the\n"
+        "broader market.\n\n"
+        "A beta of 1.0 means the stock moves in line with the market. Above 1.0\n"
+        "means it amplifies market swings — higher potential reward but more\n"
+        "volatility. Below 1.0 means it moves less than the market — more\n"
+        "stability but typically lower upside in bull markets."
+    ),
+    "30D Volatility": (
+        "How much the stock's price has fluctuated on a day-to-day basis over\n"
+        "the past 30 trading days, scaled to an annual rate.\n\n"
+        "Higher volatility means larger and more unpredictable price swings,\n"
+        "which increases the risk of short-term losses. It is calculated from\n"
+        "the standard deviation of daily price returns, then annualized so\n"
+        "it can be compared across different stocks."
+    ),
+}
+
+
+# ---------------------------------------------------------------------------
+# Main application
+# ---------------------------------------------------------------------------
+
+class ScreenerApp(tk.Tk):
+
+    def __init__(self):
+        super().__init__()
+
+        # ── DPI font calibration ────────────────────────────────────────────
+        # _S is already computed at module level via GetDeviceCaps (before any
+        # Tk window existed).  Here we only sync Tcl/Tk's scaling factor so
+        # font *point* sizes are converted to the correct physical pixel count.
+        try:
+            self.tk.call('tk', 'scaling', (_S * 96.0) / 72.0)
+        except Exception:
+            pass
+
+        self.title(_WINDOW_TITLE)
+        self.minsize(900, 560)
+        self.state("zoomed")
+        self.configure(bg=T["bg"])
+
+        self._q: queue.Queue = queue.Queue()
+        self._df = None
+        self._stop_event      = threading.Event()
+        self._run_id          = 0
+        self._sort_col        = None
+        self._sort_asc        = False
+        self._df_raw          = None   # unscored raw data — kept for re-scoring on strategy change
+        self._info_popup      = None
+        self._selected_ticker = None
+        self._score_bars: dict = {}
+
+        # Filter variables (used by popup and _apply_filters)
+        self._filter_price_min  = tk.StringVar()
+        self._filter_price_max  = tk.StringVar()
+        self._filter_mktcap     = tk.StringVar(value="Any")
+        self._filter_score_min  = tk.StringVar()
+        self._filter_ret_period = tk.StringVar(value="Any")
+        self._filter_ret_min    = tk.StringVar()
+        self._filter_upside_min = tk.StringVar()
+        self._filter_sort_by    = tk.StringVar(value="Score ↓")
+        self._search_var        = tk.StringVar()
+        self._custom_weights    = None
+        self._filters_window    = None
+
+        self._apply_styles()
+        self._build_toolbar()
+        self._build_tab_bar()
+        self._build_progress_bar()
+        self._build_main_pane()
+        self._build_status_bar()
+
+        self.after(100, self._poll_queue)
+
+    # ------------------------------------------------------------------ #
+    # Styles                                                               #
+    # ------------------------------------------------------------------ #
+
+    def _apply_styles(self):
+        s = ttk.Style(self)
+        s.theme_use("clam")
+        s.configure(".", background=T["bg"], foreground=T["fg"], font=T["font_ui"],
+                    bordercolor=T["border"], darkcolor=T["bg"], lightcolor=T["bg"],
+                    troughcolor=T["bg3"], selectbackground=T["sel"],
+                    selectforeground=T["accent"])
+
+        # ── Treeview ────────────────────────────────────────────────────
+        s.configure("Treeview",
+            background=T["bg"], foreground=T["fg"],
+            fieldbackground=T["bg"], rowheight=_s(30),
+            borderwidth=0, font=T["font_mono"])
+        s.configure("Treeview.Heading",
+            background=T["bg"], foreground=T["fg2"],
+            font=T["font_sec"], relief="flat", padding=(6, 6))
+        s.map("Treeview",
+            background=[("selected", T["sel"])],
+            foreground=[("selected", T["accent"])])
+        s.map("Treeview.Heading",
+            background=[("active", T["bg3"])],
+            foreground=[("active", T["accent"])])
+
+        # ── Scrollbar ────────────────────────────────────────────────────
+        s.configure("TScrollbar",
+            background=T["bg3"], troughcolor=T["bg"],
+            borderwidth=0, arrowsize=12, relief="flat",
+            arrowcolor=T["bg3"])
+        s.map("TScrollbar",
+            background=[("active", T["fg2"])])
+
+        # ── Buttons ──────────────────────────────────────────────────────
+        s.configure("Accent.TButton",
+            background=T["accent"], foreground="#000000",
+            font=("Segoe UI", 10, "bold"), padding=(16, 7), relief="flat", borderwidth=0)
+        s.map("Accent.TButton",
+            background=[("active", "#00c060")],
+            foreground=[("active", "#000000")])
+
+        # ── Combobox ─────────────────────────────────────────────────────
+        s.configure("TSpinbox",
+            background=T["accent"], foreground="#000000",
+            fieldbackground=T["accent"], insertcolor="#000000",
+            arrowcolor="#000000", bordercolor=T["bg"], borderwidth=0)
+
+        s.configure("TCheckbutton",
+            background=T["bg"], foreground=T["fg2"], font=T["font_small"])
+
+        s.configure("TCombobox",
+            background=T["accent"], foreground="#000000",
+            fieldbackground=T["accent"], selectbackground=T["accent"],
+            selectforeground="#000000", insertcolor="#000000",
+            arrowcolor="#000000", bordercolor=T["bg"],
+            borderwidth=0, relief="flat", padding=0, font=T["font_small"])
+        s.map("TCombobox",
+            fieldbackground=[("readonly", T["accent"])],
+            foreground=[("readonly", "#000000")],
+            selectbackground=[("readonly", T["accent"])],
+            background=[("active", "#00c060")],
+            arrowcolor=[("active", "#000000")])
+        # Strip the field border drawn by the clam theme
+        try:
+            s.layout("TCombobox", [
+                ("Combobox.field", {"sticky": "nswe", "children": [
+                    ("Combobox.downarrow", {"side": "right", "sticky": "ns"}),
+                    ("Combobox.padding", {"expand": "1", "sticky": "nswe", "children": [
+                        ("Combobox.textarea", {"sticky": "nswe"})
+                    ]})
+                ]})
+            ])
+        except Exception:
+            pass
+
+        # ── Progress bar ─────────────────────────────────────────────────
+        s.configure("Progress.Horizontal.TProgressbar",
+            troughcolor=T["bg3"], background=T["accent"],
+            borderwidth=0, thickness=3)
+
+        # ── Notebook (tabs) ──────────────────────────────────────────────
+        s.configure("TNotebook",
+            background=T["bg"], borderwidth=0, tabmargins=(0, 0, 0, 0))
+        s.configure("TNotebook.Tab",
+            background=T["bg"], foreground=T["fg2"],
+            padding=(18, 8), font=("Segoe UI", 10), borderwidth=0)
+        s.map("TNotebook.Tab",
+            background=[("selected", T["bg"]), ("active", T["bg3"])],
+            foreground=[("selected", T["accent"]), ("active", T["fg"])])
+        # Remove notebook content area border
+        try:
+            s.layout("TNotebook", [("Notebook.client", {"sticky": "nswe"})])
+        except Exception:
+            pass
+
+        s.configure("TFrame", background=T["bg"])
+        # Minimal scrollbar — thin and unobtrusive
+        s.configure("TScrollbar", width=6, arrowsize=0,
+            background=T["bg3"], troughcolor=T["bg"],
+            borderwidth=0, relief="flat", arrowcolor=T["bg"])
+
+    # ------------------------------------------------------------------ #
+    # Toolbar                                                              #
+    # ------------------------------------------------------------------ #
+
+    def _build_toolbar(self):
+        outer = tk.Frame(self, bg=T["bg"])
+        outer.pack(fill="x", side="top")
+        bar = tk.Frame(outer, bg=T["bg"], pady=_s(9))
+        bar.pack(fill="x", padx=_s(12))
+        tk.Frame(outer, bg=T["border"], height=1).pack(fill="x")
+
+        # Logo / title
+        tk.Label(bar, text=f"  {_APP_NAME.upper()}", bg=T["bg"], fg=T["accent"],
+                 font=("Segoe UI", 13, "bold")).pack(side="left", padx=(0, _s(4)))
+        tk.Label(bar, text=f"v{_APP_VERSION}", bg=T["bg"], fg=T["fg2"],
+                 font=("Segoe UI", 9)).pack(side="left", padx=(0, _s(6)))
+        _channel_badge_color = T["yellow"] if _CHANNEL == "beta" else T["accent"]
+        tk.Label(bar, text=_channel_label.upper(), bg=_channel_badge_color, fg="#000000",
+                 font=("Segoe UI", 8, "bold"), padx=_s(6), pady=_s(2)
+                 ).pack(side="left", padx=(0, _s(14)))
+
+        self._run_btn = _RoundedButton(bar, "▶  Run", self._on_run,
+                                       width=_s(100), height=_s(34), radius=_s(10))
+        self._run_btn.pack(side="left", padx=(0, _s(6)))
+
+        self._stop_btn = _RoundedButton(bar, "■  Stop", self._on_stop,
+                                        width=_s(100), height=_s(34), radius=_s(10),
+                                        bg=T["bg"], fg=T["red"], border=T["red"])
+        self._stop_btn.pack(side="left", padx=(0, _s(4)))
+        self._stop_btn.set_state("disabled")
+
+        def _sep():
+            tk.Frame(bar, bg=T["border"], width=1, height=_s(20)).pack(
+                side="left", padx=_s(10), fill="y")
+
+        _sep()
+
+        tk.Label(bar, text="Show", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+        self._top_var = tk.StringVar(value="50")
+        _RoundedDropdown(bar, self._top_var, ["50", "100", "150"],
+                         width=_s(68), height=_s(28),
+                         on_change=self._apply_filters
+                         ).pack(side="left", padx=(_s(6), 0))
+
+        _sep()
+
+        tk.Label(bar, text="Index", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+        self._index_var = tk.StringVar(value="All")
+        _RoundedDropdown(bar, self._index_var, INDEX_CHOICES,
+                         width=_s(110), height=_s(28)
+                         ).pack(side="left", padx=(_s(6), 0))
+
+        _sep()
+
+        tk.Label(bar, text="Sector", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+        self._sector_var = tk.StringVar(value="All Sectors")
+        _RoundedDropdown(bar, self._sector_var, SECTOR_CHOICES,
+                         width=_s(120), height=_s(28),
+                         on_change=self._apply_filters
+                         ).pack(side="left", padx=(_s(6), 0))
+
+        _sep()
+
+        tk.Label(bar, text="Strategy", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+        self._strategy_var = tk.StringVar(value="Balanced (Default)")
+        _RoundedDropdown(bar, self._strategy_var,
+                         list(STRATEGY_PRESETS.keys()) + ["Custom..."],
+                         width=_s(160), height=_s(28),
+                         on_change=self._on_strategy_change,
+                         tooltips=STRATEGY_DESCRIPTIONS,
+                         ).pack(side="left", padx=(_s(6), 0))
+
+        _sep()
+
+        _RoundedButton(bar, "⚙  Filters", self._open_filters_dialog,
+                       width=_s(100), height=_s(30), radius=_s(8)
+                       ).pack(side="left", padx=(0, _s(4)))
+
+        _RoundedButton(bar, "?", self._open_about_dialog,
+                       width=_s(30), height=_s(30), radius=_s(8),
+                       bg=T["bg3"], fg=T["fg2"], border=T["bg3"]
+                       ).pack(side="right", padx=(_s(4), 0))
+
+        self._lastrun_var = tk.StringVar(value="")
+        tk.Label(bar, textvariable=self._lastrun_var, bg=T["bg"], fg=T["fg2"],
+                 font=("Segoe UI", 9)).pack(side="right")
+
+    # ------------------------------------------------------------------ #
+    # Tab bar                                                              #
+    # ------------------------------------------------------------------ #
+
+    def _build_tab_bar(self):
+        outer = tk.Frame(self, bg=T["bg"])
+        outer.pack(fill="x", side="top")
+        bar = tk.Frame(outer, bg=T["bg"])
+        bar.pack(fill="x", padx=_s(12), pady=0)
+        tk.Frame(outer, bg=T["border"], height=1).pack(fill="x")
+
+        self._tab_btn_refs = {}
+        _tab_cmds = {
+            "Screener": self._show_screener_tab,
+            "Search":   self._show_search_tab,
+            "Tracking": self._show_tracking_tab,
+        }
+        tabs = [("Screener", True), ("Search", False), ("Tracking", False)]
+        for name, active in tabs:
+            cmd = _tab_cmds[name]
+            btn = _RoundedButton(bar, name, cmd,
+                                 width=_s(100), height=_s(30), radius=_s(8),
+                                 bg=T["accent"] if active else T["bg3"],
+                                 fg="#000000" if active else T["fg2"],
+                                 border=T["accent"] if active else T["bg3"])
+            btn.pack(side="left", pady=_s(8), padx=(0, _s(6)))
+            self._tab_btn_refs[name] = btn
+
+    def _update_tab_active(self, active_name: str):
+        for name, btn in self._tab_btn_refs.items():
+            is_active = (name == active_name)
+            btn._bg     = T["accent"] if is_active else T["bg3"]
+            btn._fg     = "#000000"   if is_active else T["fg2"]
+            btn._border = T["accent"] if is_active else T["bg3"]
+            btn.itemconfig(btn._rect, fill=btn._bg, outline=btn._border)
+            btn.itemconfig(btn._lbl,  fill=btn._fg)
+
+    def _show_screener_tab(self):
+        if hasattr(self, "_search_view") and self._search_view is not None:
+            self._search_view.pack_forget()
+        if hasattr(self, "_tracking_view") and self._tracking_view is not None:
+            self._tracking_view.pack_forget()
+        self._main_frame.pack(fill="both", expand=True, padx=10, pady=(6, 10))
+        self._update_tab_active("Screener")
+
+    def _show_search_tab(self):
+        self._main_frame.pack_forget()
+        if hasattr(self, "_tracking_view") and self._tracking_view is not None:
+            self._tracking_view.pack_forget()
+        if not hasattr(self, "_search_view") or self._search_view is None:
+            self._search_view = _SearchTabView(
+                self, df=self._df, df_raw=self._df_raw,
+                get_weights=self._get_current_weights,
+            )
+        else:
+            self._search_view.update_df(self._df, self._df_raw)
+        self._search_view.pack(fill="both", expand=True)
+        self._update_tab_active("Search")
+
+    def _show_tracking_tab(self):
+        self._main_frame.pack_forget()
+        if hasattr(self, "_search_view") and self._search_view is not None:
+            self._search_view.pack_forget()
+        if not hasattr(self, "_tracking_view") or self._tracking_view is None:
+            self._tracking_view = _TrackingTabView(self)
+        self._tracking_view.pack(fill="both", expand=True)
+        self._tracking_view.on_show()
+        self._update_tab_active("Tracking")
+
+    # ------------------------------------------------------------------ #
+    # About popup                                                          #
+    # ------------------------------------------------------------------ #
+
+    def _open_about_dialog(self):
+        """Open a popup showing build version, channel, and latest release notes."""
+        win = tk.Toplevel(self)
+        win.title("About")
+        win.configure(bg=T["bg"])
+        win.resizable(False, False)
+        win.geometry(f"{_s(440)}x{_s(340)}")
+        win.transient(self)
+        win.grab_set()
+
+        tk.Label(win, text=_APP_NAME, bg=T["bg"], fg=T["accent"],
+                 font=("Segoe UI", 14, "bold")).pack(pady=(22, 4))
+        tk.Label(win, text=f"Version {_APP_VERSION}  •  {_channel_label} Build",
+                 bg=T["bg"], fg=T["fg2"],
+                 font=("Segoe UI", 10)).pack(pady=(0, 14))
+        tk.Frame(win, bg=T["border"], height=1).pack(fill="x", padx=20)
+
+        tk.Label(win, text="Release Notes", bg=T["bg"], fg=T["fg"],
+                 font=("Segoe UI", 10, "bold")).pack(anchor="w", padx=20, pady=(10, 4))
+
+        notes_frame = tk.Frame(win, bg=T["bg3"], padx=1, pady=1)
+        notes_frame.pack(fill="both", expand=True, padx=20, pady=(0, 14))
+
+        notes_text = tk.Text(notes_frame, bg=T["bg3"], fg=T["fg"],
+                             font=("Segoe UI", 9), wrap="word",
+                             relief="flat", borderwidth=0, padx=10, pady=8,
+                             state="disabled", height=8)
+        notes_text.pack(fill="both", expand=True)
+
+        def _set_notes(text: str):
+            notes_text.config(state="normal")
+            notes_text.delete("1.0", "end")
+            notes_text.insert("1.0", text)
+            notes_text.config(state="disabled")
+
+        _set_notes("Loading…")
+
+        def _fetch():
+            try:
+                from updater import get_release_notes
+                _, notes = get_release_notes()
+            except Exception:
+                notes = "Unable to fetch release notes."
+            win.after(0, lambda: _set_notes(notes))
+
+        threading.Thread(target=_fetch, daemon=True).start()
+
+        _RoundedButton(win, "Close", win.destroy,
+                       width=_s(80), height=_s(30), radius=_s(8),
+                       bg=T["bg3"], fg=T["fg2"], border=T["bg3"]).pack(pady=(0, _s(18)))
+
+    # ------------------------------------------------------------------ #
+    # Filters popup                                                        #
+    # ------------------------------------------------------------------ #
+
+    def _open_filters_dialog(self):
+        """Open the post-screen filters panel (non-modal, stays on top)."""
+        if self._filters_window is not None:
+            try:
+                self._filters_window.lift()
+                self._filters_window.focus_set()
+                return
+            except tk.TclError:
+                pass
+
+        win = tk.Toplevel(self)
+        self._filters_window = win
+        win.title("Filters")
+        win.configure(bg=T["bg"])
+        win.resizable(False, False)
+        win.attributes("-topmost", True)
+
+        def _on_close():
+            self._filters_window = None
+            win.destroy()
+
+        win.protocol("WM_DELETE_WINDOW", _on_close)
+
+        def _entry(parent, var, width=10):
+            pe = _PillEntry(parent, var, width_chars=width, height=26)
+            pe.entry.bind("<FocusOut>", self._apply_filters)
+            pe.entry.bind("<Return>",   self._apply_filters)
+            return pe
+
+        def _cb(parent, var, values, width=16):
+            px_w = max(_s(80), width * _s(7) + _s(24))
+            return _RoundedDropdown(parent, var, values,
+                                    width=px_w, height=_s(26),
+                                    on_change=self._apply_filters)
+
+        def _row_lbl(text, r):
+            tk.Label(win, text=text, bg=T["bg"], fg=T["fg2"],
+                     font=T["font_small"], anchor="w", width=11
+                     ).grid(row=r, column=0, padx=(18, 6), pady=5, sticky="w")
+
+        def _hsep(r):
+            tk.Frame(win, bg=T["border"], height=1).grid(
+                row=r, column=0, columnspan=3, sticky="ew", padx=14, pady=(4, 2))
+
+        # ── Title ──────────────────────────────────────────────────────────
+        tk.Label(win, text="Post-Screen Filters", bg=T["bg"], fg=T["accent"],
+                 font=T["font_head"], pady=10
+                 ).grid(row=0, column=0, columnspan=3, padx=18, sticky="w")
+
+        r = 1
+
+        # ── Price ──────────────────────────────────────────────────────────
+        _row_lbl("Price  $", r)
+        pf = tk.Frame(win, bg=T["bg"])
+        pf.grid(row=r, column=1, columnspan=2, padx=(0, 18), pady=5, sticky="w")
+        _entry(pf, self._filter_price_min, 8).pack(side="left")
+        tk.Label(pf, text="–", bg=T["bg"], fg=T["accent"],
+                 font=T["font_small"]).pack(side="left", padx=5)
+        _entry(pf, self._filter_price_max, 8).pack(side="left")
+        r += 1
+
+        # ── Sort by ────────────────────────────────────────────────────────
+        _row_lbl("Sort by", r)
+        _cb(win, self._filter_sort_by,
+            ["Score ↓", "Price ↓", "Price ↑", "Upside ↓"], width=12
+            ).grid(row=r, column=1, padx=(0, 18), pady=5, sticky="w")
+        r += 1
+
+        _hsep(r); r += 1
+
+        # ── Market cap ─────────────────────────────────────────────────────
+        _row_lbl("Market Cap", r)
+        _cb(win, self._filter_mktcap,
+            ["Any", "Mega (>$100B)", "Large ($10B–$100B)", "Mid ($2B–$10B)", "Small (<$2B)"],
+            width=16
+            ).grid(row=r, column=1, padx=(0, 18), pady=5, sticky="w")
+        r += 1
+
+        # ── Min score ──────────────────────────────────────────────────────
+        _row_lbl("Min Score", r)
+        _entry(win, self._filter_score_min, 8
+               ).grid(row=r, column=1, padx=(0, 18), pady=5, sticky="w")
+        r += 1
+
+        _hsep(r); r += 1
+
+        # ── Return filter ──────────────────────────────────────────────────
+        _row_lbl("Return", r)
+        rf = tk.Frame(win, bg=T["bg"])
+        rf.grid(row=r, column=1, columnspan=2, padx=(0, 18), pady=5, sticky="w")
+        _cb(rf, self._filter_ret_period, ["Any", "1M", "3M", "6M", "12M"], width=4
+            ).pack(side="left")
+        tk.Label(rf, text="≥", bg=T["bg"], fg=T["accent"],
+                 font=T["font_small"]).pack(side="left", padx=(8, 3))
+        _entry(rf, self._filter_ret_min, 6).pack(side="left")
+        tk.Label(rf, text="%", bg=T["bg"], fg=T["accent"],
+                 font=T["font_small"]).pack(side="left", padx=(3, 0))
+        r += 1
+
+        _hsep(r); r += 1
+
+        # ── Upside to target ───────────────────────────────────────────────
+        _row_lbl("Min Upside", r)
+        uf = tk.Frame(win, bg=T["bg"])
+        uf.grid(row=r, column=1, columnspan=2, padx=(0, 18), pady=5, sticky="w")
+        _entry(uf, self._filter_upside_min, 6).pack(side="left")
+        tk.Label(uf, text="% to target", bg=T["bg"], fg=T["accent"],
+                 font=T["font_small"]).pack(side="left", padx=(3, 0))
+        r += 1
+
+        _hsep(r); r += 1
+
+        # ── Search ─────────────────────────────────────────────────────────
+        _row_lbl("Search", r)
+        se = _entry(win, self._search_var, 18)
+        se.grid(row=r, column=1, columnspan=2, padx=(0, 18), pady=5, sticky="w")
+        se.entry.bind("<KeyRelease>", self._apply_filters)
+        r += 1
+
+        # ── Close button ───────────────────────────────────────────────────
+        _hsep(r); r += 1
+        close_wrap = tk.Frame(win, bg=T["bg"])
+        close_wrap.grid(row=r, column=0, columnspan=3, pady=(_s(6), _s(14)))
+        _RoundedButton(close_wrap, "Close", _on_close,
+                       width=_s(90), height=_s(30), radius=_s(8)).pack()
+
+        # Clicking any non-interactive surface defocuses the active entry,
+        # which fires <FocusOut> → _apply_filters automatically.
+        # Guard: do NOT steal focus from Entry widgets or _RoundedDropdown canvases —
+        # the latter also opens a popup whose own grab must not be pre-empted.
+        def _defocus(e):
+            if isinstance(e.widget, (tk.Entry, _RoundedDropdown)):
+                return
+            win.focus_set()
+        def _bind_defocus(widget):
+            if isinstance(widget, (tk.Label, tk.Frame)):
+                widget.bind("<Button-1>", _defocus, add="+")
+            for child in widget.winfo_children():
+                _bind_defocus(child)
+        win.bind("<Button-1>", _defocus, add="+")
+        _bind_defocus(win)
+
+        win.update_idletasks()
+        px = self.winfo_x() + self.winfo_width() - win.winfo_reqwidth() - 20
+        py = self.winfo_y() + 60
+        win.geometry(f"+{px}+{py}")
+
+    # ------------------------------------------------------------------ #
+    # Progress bar                                                         #
+    # ------------------------------------------------------------------ #
+
+    def _build_progress_bar(self):
+        self._progress_var = tk.DoubleVar(value=0)
+        ttk.Progressbar(self, variable=self._progress_var, maximum=100,
+                        style="Progress.Horizontal.TProgressbar",
+                        mode="determinate").pack(fill="x", side="top")
+
+    # ------------------------------------------------------------------ #
+    # Main pane — horizontal split: ticker list | tabbed detail            #
+    # ------------------------------------------------------------------ #
+
+    def _build_main_pane(self):
+        self._main_frame = tk.Frame(self, bg=T["bg"])
+        self._main_frame.pack(fill="both", expand=True, padx=_s(10), pady=(_s(6), _s(10)))
+        outer = self._main_frame
+
+        pane = tk.PanedWindow(outer, orient="horizontal",
+                              bg=T["bg"], sashwidth=_s(10),
+                              sashrelief="flat", handlesize=0)
+        pane.pack(fill="both", expand=True)
+
+        list_frame   = tk.Frame(pane, bg=T["bg"],
+                                highlightthickness=0)
+        detail_frame = tk.Frame(pane, bg=T["bg"],
+                                highlightthickness=0)
+
+        pane.add(list_frame,   minsize=_s(220))
+        pane.add(detail_frame, minsize=_s(400))
+
+        _pane_initialized = [False]
+
+        def _on_pane_resize(event):
+            if not _pane_initialized[0] and event.width > 1:
+                _pane_initialized[0] = True
+                pane.sash_place(0, event.width // 2, 0)
+        pane.bind("<Configure>", _on_pane_resize)
+
+        self._build_table(list_frame)
+        self._build_detail(detail_frame)
+
+    # ------------------------------------------------------------------ #
+    # Ticker list (left panel)                                             #
+    # ------------------------------------------------------------------ #
+
+    _COLS = [
+        ("#",       48, "center"),
+        ("Ticker",  72, "center"),
+        ("Name",   180, "w"),
+        ("Score",   60, "center"),
+        ("Sector", 140, "w"),
+    ]
+
+    def _get_top_n(self) -> int:
+        v = self._top_var.get()
+        return int(v)
+
+    def _on_strategy_change(self, _event=None):
+        """Re-score the fetched data with the selected strategy's weights, then re-filter."""
+        strategy = self._strategy_var.get()
+        if strategy == "Custom...":
+            self._open_custom_strategy_dialog()
+            return
+
+        # Re-score the main screener data if it is loaded
+        if self._df_raw is not None:
+            weights = STRATEGY_PRESETS.get(strategy)
+            self._df = score_stocks(self._df_raw, weights=weights)
+            self._apply_filters()
+            self._status_var.set(f"  Strategy: {strategy} — rescored {len(self._df)} stocks.")
+            # Refresh the detail panel if a stock is currently selected
+            selected = getattr(self, "_selected_ticker", None)
+            if selected is not None and self._df is not None:
+                match = self._df[self._df["ticker"] == selected]
+                if not match.empty:
+                    self._update_detail(match.iloc[0])
+
+        # Always refresh the search tab — it works independently of screener data
+        # (live-fetched results re-score using get_weights, df results use updated df)
+        sv = getattr(self, "_search_view", None)
+        if sv is not None:
+            sv.update_df(self._df, self._df_raw)
+            sv.refresh_current_result()
+
+    def _get_current_weights(self):
+        """Return the weight dict for the currently selected strategy."""
+        strategy = self._strategy_var.get()
+        if strategy == "Custom..." and self._custom_weights:
+            return self._custom_weights
+        return STRATEGY_PRESETS.get(strategy)  # None → default WEIGHTS
+
+    def _apply_filters(self, _event=None):
+        """
+        Filter self._df by sector, price, market cap, score, and return,
+        then repopulate the table.
+        """
+        if self._df is None:
+            return
+        df = self._df
+
+        # --- Sector ---
+        rule = _SECTOR_FILTER_MAP.get(self._sector_var.get())
+        if rule is not None:
+            col, val = rule
+            if col in df.columns:
+                df = df[df[col] == val]
+
+        # --- Search (ticker or name) ---
+        search_q = self._search_var.get().strip()
+        if search_q:
+            q = search_q.lower()
+            mask = (
+                df["ticker"].str.lower().str.contains(q, na=False, regex=False) |
+                df["name"].str.lower().str.contains(q, na=False, regex=False)
+            )
+            df = df[mask]
+
+        # --- Price range ---
+        def _to_float(sv):
+            try:
+                return float(sv.get().replace("$", "").replace(",", "").strip())
+            except ValueError:
+                return None
+
+        # Coerce filter columns to numeric — guards against any stray string
+        # values that yfinance may have returned for edge-case NYSE securities.
+        import pandas as _pd
+        for _col in ("price", "market_cap", "composite_score",
+                     "ret_1m", "ret_3m", "ret_6m", "ret_12m", "analyst_upside"):
+            if _col in df.columns:
+                df = df.copy()
+                df[_col] = _pd.to_numeric(df[_col], errors="coerce")
+
+        price_min = _to_float(self._filter_price_min)
+        price_max = _to_float(self._filter_price_max)
+        if price_min is not None:
+            df = df[df["price"].fillna(0) >= price_min]
+        if price_max is not None:
+            df = df[df["price"].fillna(0) <= price_max]
+
+        # --- Market cap category ---
+        mktcap_cat = self._filter_mktcap.get()
+        if mktcap_cat != "Any" and "market_cap" in df.columns:
+            if mktcap_cat.startswith("Mega"):
+                df = df[df["market_cap"].fillna(0) >= 100e9]
+            elif mktcap_cat.startswith("Large"):
+                df = df[(df["market_cap"].fillna(0) >= 10e9) &
+                        (df["market_cap"].fillna(0) < 100e9)]
+            elif mktcap_cat.startswith("Mid"):
+                df = df[(df["market_cap"].fillna(0) >= 2e9) &
+                        (df["market_cap"].fillna(0) < 10e9)]
+            elif mktcap_cat.startswith("Small"):
+                df = df[df["market_cap"].fillna(0) < 2e9]
+
+        # --- Minimum composite score ---
+        score_min = _to_float(self._filter_score_min)
+        if score_min is not None and "composite_score" in df.columns:
+            df = df[df["composite_score"].fillna(0) >= score_min]
+
+        # --- Return filter ---
+        ret_period = self._filter_ret_period.get()
+        ret_min    = _to_float(self._filter_ret_min)
+        _ret_col_map = {"1M": "ret_1m", "3M": "ret_3m", "6M": "ret_6m", "12M": "ret_12m"}
+        if ret_period != "Any" and ret_min is not None:
+            col = _ret_col_map.get(ret_period)
+            if col and col in df.columns:
+                df = df[df[col].fillna(-999) >= ret_min / 100.0]
+
+        # --- Upside to target filter ---
+        upside_min = _to_float(self._filter_upside_min)
+        if upside_min is not None and "analyst_upside" in df.columns:
+            df = df[df["analyst_upside"].fillna(-999) >= upside_min / 100.0]
+
+        # --- Sort ---
+        sort_by = self._filter_sort_by.get()
+        if sort_by == "Price ↓" and "price" in df.columns:
+            df = df.sort_values("price", ascending=False, na_position="last")
+        elif sort_by == "Price ↑" and "price" in df.columns:
+            df = df.sort_values("price", ascending=True, na_position="last")
+        elif sort_by == "Upside ↓" and "analyst_upside" in df.columns:
+            df = df.sort_values("analyst_upside", ascending=False, na_position="last")
+        # "Score ↓" keeps the composite_score order from score_stocks
+
+        top_n = self._get_top_n()
+        self._populate_table(df.head(top_n))
+
+        # Update status
+        n_shown = min(len(df), top_n)
+        total   = len(df)
+        parts   = []
+        sector  = self._sector_var.get()
+        if sector != "All Sectors":
+            parts.append(sector)
+        if price_min is not None or price_max is not None:
+            lo = f"${price_min:.0f}" if price_min is not None else "$0"
+            hi = f"${price_max:.0f}" if price_max is not None else "∞"
+            parts.append(f"Price {lo}–{hi}")
+        if mktcap_cat != "Any":
+            parts.append(mktcap_cat.split(" ")[0])
+        if score_min is not None:
+            parts.append(f"Score≥{score_min:.0f}")
+        if ret_period != "Any" and ret_min is not None:
+            parts.append(f"{ret_period}≥{ret_min:.0f}%")
+        if upside_min is not None:
+            parts.append(f"Upside≥{upside_min:.0f}%")
+        if sort_by != "Score ↓":
+            parts.append(f"Sort: {sort_by}")
+        suffix = " — " + ", ".join(parts) if parts else ""
+        self._status_var.set(
+            f"  Showing {n_shown} of {total} matching stocks{suffix}. "
+            "Click a ticker to see details.")
+
+        # If a stock is currently displayed, keep it live even after filtering
+        selected = getattr(self, "_selected_ticker", None)
+        if selected is not None and self._df is not None:
+            match = self._df[self._df["ticker"] == selected]
+            if not match.empty:
+                self._update_detail(match.iloc[0])
+
+    def _build_table(self, parent):
+        # Card header
+        tk.Label(parent, text="Results", bg=T["bg"], fg=T["accent"],
+                 font=T["font_head"], anchor="w", padx=16, pady=10,
+                 ).grid(row=0, column=0, columnspan=2, sticky="ew")
+        tk.Frame(parent, bg=T["border"], height=1,
+                 ).grid(row=1, column=0, columnspan=2, sticky="ew")
+
+        cols = [c[0] for c in self._COLS]
+
+        self._tree = ttk.Treeview(parent, columns=cols, show="headings",
+                                  selectmode="browse")
+
+        for col, width, anchor in self._COLS:
+            self._tree.heading(col, text=col,
+                               command=lambda c=col: self._sort_column(c))
+            self._tree.column(col, width=_s(width), anchor=anchor,
+                              stretch=(col == "Name"))
+
+        self._tree.tag_configure("odd",  background=T["row_odd"],  foreground=T["fg"])
+        self._tree.tag_configure("even", background=T["row_even"], foreground=T["fg"])
+
+        vsb = ttk.Scrollbar(parent, orient="vertical",   command=self._tree.yview)
+        hsb = ttk.Scrollbar(parent, orient="horizontal", command=self._tree.xview)
+        self._tree.configure(yscrollcommand=vsb.set, xscrollcommand=hsb.set)
+
+        self._tree.grid(row=2, column=0, sticky="nsew")
+        vsb.grid(row=2, column=1, sticky="ns")
+        hsb.grid(row=3, column=0, sticky="ew")
+        parent.grid_rowconfigure(2, weight=1)
+        parent.grid_columnconfigure(0, weight=1)
+
+        self._tree.bind("<<TreeviewSelect>>", self._on_row_select)
+
+    def _populate_table(self, df):
+        self._tree.delete(*self._tree.get_children())
+        for i, (_, row) in enumerate(df.iterrows()):
+            tag = "odd" if i % 2 else "even"
+            self._tree.insert("", "end", iid=str(i), tags=(tag,), values=(
+                i + 1,
+                row["ticker"],
+                str(row.get("name", ""))[:30],
+                _score(row.get("composite_score")),
+                str(row.get("sector", ""))[:22],
+            ))
+
+    def _sort_column(self, col: str):
+        if self._sort_col == col:
+            self._sort_asc = not self._sort_asc
+        else:
+            self._sort_col = col
+            self._sort_asc = False
+
+        data = [(self._tree.set(iid, col), iid)
+                for iid in self._tree.get_children("")]
+
+        def _key(v):
+            s = v.replace("%", "").replace("$", "").replace(",", "").strip()
+            try:
+                if s.endswith("T"): return (0, float(s[:-1]) * 1e12)
+                if s.endswith("B"): return (0, float(s[:-1]) * 1e9)
+                if s.endswith("M"): return (0, float(s[:-1]) * 1e6)
+                return (0, float(s))
+            except (ValueError, AttributeError):
+                return (1, s.lower())
+
+        data.sort(key=lambda x: _key(x[0]), reverse=not self._sort_asc)
+        for i, (_, iid) in enumerate(data):
+            self._tree.move(iid, "", i)
+            self._tree.item(iid, tags=("odd" if i % 2 else "even",))
+
+        arrow = " ▲" if self._sort_asc else " ▼"
+        for c, _, _ in self._COLS:
+            self._tree.heading(c, text=(c + arrow if c == col else c))
+
+    # ------------------------------------------------------------------ #
+    # Tabbed detail panel (right panel)                                    #
+    # ------------------------------------------------------------------ #
+
+    def _build_detail(self, parent):
+        # Stock title bar
+        self._detail_title = tk.Label(
+            parent,
+            text="  ← Select a stock from the list",
+            bg=T["bg"], fg=T["fg2"], font=T["font_head"],
+            anchor="w", pady=12, padx=16)
+        self._detail_title.pack(fill="x", side="top")
+        tk.Frame(parent, bg=T["border"], height=1).pack(fill="x")
+
+        # Notebook — hidden until a ticker is selected
+        self._notebook = _CustomNotebook(parent)
+        self._notebook.pack(fill="both", expand=True, padx=0, pady=0)
+        self._notebook.pack_forget()
+
+        self._detail_labels: dict = {}
+
+        # Scores tab — animated bar widgets
+        scores_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(scores_tab, text="  Scores  ")
+        self._build_scores_tab_content(scores_tab)
+
+        for title, fields in [
+            ("Valuation",        self._VAL_FIELDS),
+            ("Growth",           self._GROWTH_FIELDS),
+            ("Momentum",         self._MOM_FIELDS),
+            ("Quality & Profit", self._QUAL_FIELDS),
+        ]:
+            tab = tk.Frame(self._notebook, bg=T["bg"])
+            self._notebook.add(tab, text=f"  {title}  ")
+            labels = self._build_tab_content(tab, fields)
+            self._detail_labels.update(labels)
+
+        # Analyst tab — key-value metrics on top, commentary box below
+        analyst_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(analyst_tab, text="  Analyst  ")
+        self._build_analyst_tab(analyst_tab)
+
+        # Chart tab
+        self._chart_ticker = None
+        chart_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(chart_tab, text="  Chart  ")
+        self._build_chart_tab(chart_tab)
+
+    def _build_tab_content(self, parent, fields) -> dict:
+        """
+        Scrollable two-column key/value grid inside a notebook tab.
+        Both scrollbars appear only when needed; content is scroll-locked otherwise.
+        """
+        # Both scrollbars are dynamic — only shown when content overflows
+        hsb = ttk.Scrollbar(parent, orient="horizontal")
+        vsb = ttk.Scrollbar(parent, orient="vertical")
+
+        canvas = tk.Canvas(parent, bg=T["bg"], highlightthickness=0, bd=0,
+                           xscrollcommand=hsb.set, yscrollcommand=vsb.set)
+        canvas.pack(side="left", fill="both", expand=True)
+        hsb.config(command=canvas.xview)
+        vsb.config(command=canvas.yview)
+
+        inner = tk.Frame(canvas, bg=T["bg"])
+        win_id = canvas.create_window((0, 0), window=inner, anchor="nw")
+
+        labels = {}
+        for i, (label, key) in enumerate(fields):
+            r = i * 2
+            # Key label
+            key_lbl = tk.Label(inner, text=label, bg=T["bg"], fg=T["fg2"],
+                               font=T["font_small"], anchor="w", padx=16, pady=6,
+                               width=18)
+            key_lbl.grid(row=r, column=0, sticky="w")
+            # Info button (column 1)
+            has_tip = label in _METRIC_TOOLTIPS or label == "Composite Score"
+            if has_tip:
+                btn = tk.Button(
+                    inner, text="ⓘ",
+                    bg=T["bg"], fg=T["accent"],
+                    activebackground=T["bg"], activeforeground=T["fg"],
+                    font=("Segoe UI", 9), bd=0, relief="flat",
+                    cursor="hand2", padx=2, pady=0,
+                )
+                btn.configure(command=lambda b=btn, l=label: self._show_info_popup(
+                    b, self._get_tooltip_text(l)))
+                btn.grid(row=r, column=1, sticky="w", pady=6)
+            # Value label (column 2)
+            val_lbl = tk.Label(inner, text="—", bg=T["bg"], fg=T["fg"],
+                               font=("Consolas", 12), anchor="w", padx=8, pady=6)
+            val_lbl.grid(row=r, column=2, sticky="w")
+            labels[key] = val_lbl
+            # Separator
+            tk.Frame(inner, bg=T["border"], height=1
+                     ).grid(row=r + 1, column=0, columnspan=3,
+                            sticky="ew", padx=12, pady=0)
+
+        inner.grid_columnconfigure(2, weight=1)
+
+        def _update_scrollbars(cw, ch):
+            iw = inner.winfo_reqwidth()
+            ih = inner.winfo_reqheight()
+            canvas.configure(scrollregion=(0, 0, iw, ih))
+            if ih > ch:
+                vsb.pack(side="right", fill="y", before=canvas)
+            else:
+                vsb.pack_forget()
+                canvas.yview_moveto(0)
+            if iw > cw:
+                hsb.pack(side="bottom", fill="x", before=canvas)
+            else:
+                hsb.pack_forget()
+                canvas.xview_moveto(0)
+
+        def _on_inner_cfg(event):
+            _update_scrollbars(canvas.winfo_width(), canvas.winfo_height())
+
+        def _on_canvas_cfg(event):
+            canvas.itemconfigure(win_id, width=max(event.width,
+                                                    inner.winfo_reqwidth()))
+            _update_scrollbars(event.width, event.height)
+
+        inner.bind("<Configure>", _on_inner_cfg)
+        canvas.bind("<Configure>", _on_canvas_cfg)
+
+        def _scroll_y(e):
+            if inner.winfo_reqheight() > canvas.winfo_height():
+                canvas.yview_scroll(int(-1 * (e.delta / 120)), "units")
+        def _scroll_x(e):
+            if inner.winfo_reqwidth() > canvas.winfo_width():
+                canvas.xview_scroll(int(-1 * (e.delta / 120)), "units")
+
+        canvas.bind("<MouseWheel>", _scroll_y)
+        inner.bind("<MouseWheel>",  _scroll_y)
+        canvas.bind("<Shift-MouseWheel>", _scroll_x)
+        inner.bind("<Shift-MouseWheel>",  _scroll_x)
+
+        return labels
+
+    def _build_scores_tab_content(self, parent) -> None:
+        """
+        Build the Scores tab with animated _ScoreBar widgets instead of text labels.
+        Bars are stored in self._score_bars (not in _detail_labels).
+        """
+        hsb = ttk.Scrollbar(parent, orient="horizontal")
+        vsb = ttk.Scrollbar(parent, orient="vertical")
+
+        canvas = tk.Canvas(parent, bg=T["bg"], highlightthickness=0, bd=0,
+                           xscrollcommand=hsb.set, yscrollcommand=vsb.set)
+        canvas.pack(side="left", fill="both", expand=True)
+        hsb.config(command=canvas.xview)
+        vsb.config(command=canvas.yview)
+
+        inner = tk.Frame(canvas, bg=T["bg"])
+        win_id = canvas.create_window((0, 0), window=inner, anchor="nw")
+
+        for i, (label, key) in enumerate(self._SCORE_FIELDS):
+            r = i * 2
+            # Label column
+            tk.Label(inner, text=label, bg=T["bg"], fg=T["fg2"],
+                     font=T["font_small"], anchor="w", padx=16, pady=6,
+                     width=18).grid(row=r, column=0, sticky="w")
+            # Info button column
+            has_tip = label in _METRIC_TOOLTIPS or label == "Composite Score"
+            if has_tip:
+                btn = tk.Button(
+                    inner, text="ⓘ",
+                    bg=T["bg"], fg=T["accent"],
+                    activebackground=T["bg"], activeforeground=T["fg"],
+                    font=("Segoe UI", 9), bd=0, relief="flat",
+                    cursor="hand2", padx=2, pady=0,
+                )
+                btn.configure(command=lambda b=btn, l=label: self._show_info_popup(
+                    b, self._get_tooltip_text(l)))
+                btn.grid(row=r, column=1, sticky="w", pady=6)
+            # Score bar column
+            bar = _ScoreBar(inner, bg=T["bg"])
+            bar.grid(row=r, column=2, sticky="w", padx=(8, 24), pady=4)
+            self._score_bars[key] = bar
+            # Separator
+            tk.Frame(inner, bg=T["border"], height=1
+                     ).grid(row=r + 1, column=0, columnspan=3,
+                            sticky="ew", padx=12, pady=0)
+
+        inner.grid_columnconfigure(2, weight=1)
+
+        def _update_scrollbars_scores(cw, ch):
+            iw = inner.winfo_reqwidth()
+            ih = inner.winfo_reqheight()
+            canvas.configure(scrollregion=(0, 0, iw, ih))
+            if ih > ch:
+                vsb.pack(side="right", fill="y", before=canvas)
+            else:
+                vsb.pack_forget()
+                canvas.yview_moveto(0)
+            if iw > cw:
+                hsb.pack(side="bottom", fill="x", before=canvas)
+            else:
+                hsb.pack_forget()
+                canvas.xview_moveto(0)
+
+        def _on_inner_cfg(event):
+            _update_scrollbars_scores(canvas.winfo_width(), canvas.winfo_height())
+
+        def _on_canvas_cfg(event):
+            canvas.itemconfigure(win_id, width=max(event.width,
+                                                    inner.winfo_reqwidth()))
+            _update_scrollbars_scores(event.width, event.height)
+
+        inner.bind("<Configure>", _on_inner_cfg)
+        canvas.bind("<Configure>", _on_canvas_cfg)
+
+        def _scroll_y(e):
+            if inner.winfo_reqheight() > canvas.winfo_height():
+                canvas.yview_scroll(int(-1 * (e.delta / 120)), "units")
+        canvas.bind("<MouseWheel>", _scroll_y)
+        inner.bind("<MouseWheel>",  _scroll_y)
+
+    def _update_score_bars(self, row) -> None:
+        """Animate all score bars to the values in row. Resets first."""
+        import math
+        for key, bar in self._score_bars.items():
+            val = row.get(key)
+            try:
+                if val is None or (isinstance(val, float) and math.isnan(val)):
+                    bar.reset()
+                else:
+                    bar.animate_to(float(val))
+            except (TypeError, ValueError):
+                bar.reset()
+
+    def _build_analyst_tab(self, parent):
+        """
+        Analyst tab: key-value metrics (top third) + commentary box (bottom two-thirds).
+        """
+        # ---- Key-value metrics (top) ----
+        metrics_frame = tk.Frame(parent, bg=T["bg"])
+        metrics_frame.pack(fill="x", side="top")
+        labels = self._build_tab_content(metrics_frame, self._ANLST_FIELDS)
+        self._detail_labels.update(labels)
+
+        # ---- Divider ----
+        tk.Frame(parent, bg=T["border"], height=1).pack(fill="x", pady=(4, 0))
+
+        # ---- Commentary header ----
+        hdr = tk.Frame(parent, bg=T["bg"])
+        hdr.pack(fill="x")
+        tk.Label(hdr, text="  Analyst Commentary", bg=T["bg"], fg=T["accent"],
+                 font=T["font_sec"], anchor="w", pady=5
+                 ).pack(side="left", padx=4)
+        tk.Label(hdr, text="auto-generated from market data",
+                 bg=T["bg"], fg=T["fg2"], font=T["font_small"],
+                 anchor="w").pack(side="left")
+
+        # ---- Commentary text box ----
+        txt_frame = tk.Frame(parent, bg=T["bg"])
+        txt_frame.pack(fill="both", expand=True, padx=6, pady=6)
+
+        self._commentary_box = tk.Text(
+            txt_frame,
+            bg=T["bg3"], fg=T["fg"],
+            font=("Consolas", 11),
+            wrap="word",
+            relief="flat",
+            bd=0,
+            highlightthickness=0,
+            padx=14, pady=10,
+            state="disabled",
+            cursor="arrow",
+        )
+        txt_vsb = ttk.Scrollbar(txt_frame, orient="vertical",
+                                command=self._commentary_box.yview)
+        self._commentary_box.configure(yscrollcommand=txt_vsb.set)
+
+        self._commentary_box.pack(side="left", fill="both", expand=True)
+        txt_vsb.pack(side="right", fill="y")
+
+        # Text colour tags
+        self._commentary_box.tag_configure("heading",
+            foreground=T["accent"], font=("Segoe UI", 11, "bold"))
+        self._commentary_box.tag_configure("bullet",
+            foreground=T["fg"],    font=("Consolas", 11))
+        self._commentary_box.tag_configure("positive",
+            foreground=T["green"], font=("Consolas", 11))
+        self._commentary_box.tag_configure("negative",
+            foreground=T["red"],   font=("Consolas", 11))
+        self._commentary_box.tag_configure("neutral",
+            foreground=T["yellow"],font=("Consolas", 11))
+        self._commentary_box.tag_configure("verdict_buy",
+            foreground=T["green"], font=("Segoe UI", 12, "bold"))
+        self._commentary_box.tag_configure("verdict_hold",
+            foreground=T["yellow"],font=("Segoe UI", 12, "bold"))
+        self._commentary_box.tag_configure("verdict_sell",
+            foreground=T["red"],   font=("Segoe UI", 12, "bold"))
+        self._commentary_box.tag_configure("dim",
+            foreground=T["fg2"],   font=("Segoe UI", 9))
+        self._commentary_box.tag_configure("description",
+            foreground=T["fg2"],   font=("Segoe UI", 10),
+            spacing1=2, spacing3=4)
+
+    # ------------------------------------------------------------------ #
+    # Chart tab                                                           #
+    # ------------------------------------------------------------------ #
+
+    def _build_chart_tab(self, parent, notebook=None, chart_attr="_chart_canvas",
+                         period_attr="_chart_period", ticker_attr="_chart_ticker"):
+        """Build the price-chart tab UI inside `parent`."""
+        self._chart_parent_frame = parent
+
+        # Period selector row
+        ctrl = tk.Frame(parent, bg=T["bg"])
+        ctrl.pack(fill="x", side="top", padx=0, pady=0)
+        tk.Frame(ctrl, bg=T["bg"], width=_s(12)).pack(side="left")
+        periods = ["1mo", "3mo", "6mo", "1y", "2y", "5y"]
+        labels  = ["1M",  "3M",  "6M",  "1Y", "2Y", "5Y"]
+        period_var = tk.StringVar(value="6mo")
+        setattr(self, period_attr, period_var)
+        for val, lbl in zip(periods, labels):
+            b = tk.Radiobutton(
+                ctrl, text=lbl, variable=period_var, value=val,
+                bg=T["bg"],
+                fg=T["fg2"],
+                selectcolor=T["accent"],
+                activebackground=T["bg"],
+                activeforeground=T["accent"],
+                font=("Segoe UI", 9, "bold"),
+                indicatoron=False,
+                relief="flat", overrelief="flat",
+                padx=_s(10), pady=_s(5), bd=0,
+                cursor="hand2",
+                command=lambda: self._trigger_chart_update(
+                    ticker_attr, period_attr, chart_attr, parent),
+            )
+            b.pack(side="left", padx=1, pady=(_s(4), 0))
+        tk.Frame(ctrl, bg=T["border"], height=1).pack(fill="x", side="bottom")
+
+        # Canvas placeholder
+        placeholder = tk.Label(
+            parent,
+            text="Select a stock to view its price chart.",
+            bg=T["bg"], fg=T["fg2"], font=T["font_small"],
+        )
+        placeholder.pack(expand=True)
+        setattr(self, chart_attr + "_placeholder", placeholder)
+        setattr(self, chart_attr, None)
+
+    def _trigger_chart_update(self, ticker_attr, period_attr, chart_attr, parent):
+        ticker = getattr(self, ticker_attr, None)
+        period = getattr(self, period_attr).get()
+        if ticker:
+            threading.Thread(
+                target=self._fetch_and_render_chart,
+                args=(ticker, period, chart_attr, parent),
+                daemon=True,
+            ).start()
+
+    def _set_chart_placeholder_text(self, chart_attr: str, text: str):
+        """Update the placeholder label text (called from main thread via after())."""
+        ph = getattr(self, chart_attr + "_placeholder", None)
+        if ph:
+            try:
+                ph.config(text=text)
+                ph.pack(expand=True)
+            except Exception:
+                pass
+
+    def _fetch_and_render_chart(self, ticker: str, period: str,
+                                chart_attr: str, parent: tk.Widget):
+        """Fetch OHLCV from yfinance and schedule chart render on main thread."""
+        if not _MATPLOTLIB_OK:
+            msg = f"Chart unavailable: matplotlib not loaded. {_MATPLOTLIB_ERR}"
+            self.after(0, self._set_chart_placeholder_text, chart_attr, msg)
+            return
+        if not _YF_OK:
+            self.after(0, self._set_chart_placeholder_text, chart_attr,
+                       "Chart unavailable: yfinance not loaded.")
+            return
+        try:
+            self.after(0, self._set_chart_placeholder_text, chart_attr,
+                       f"Loading chart for {ticker}…")
+            hist = yf.Ticker(ticker).history(period=period, auto_adjust=True)
+            if hist is None or hist.empty:
+                self.after(0, self._set_chart_placeholder_text, chart_attr,
+                           f"No price history found for {ticker}.")
+                return
+            self.after(0, self._render_chart, hist, ticker, chart_attr, parent)
+        except Exception as e:
+            self.after(0, self._set_chart_placeholder_text, chart_attr,
+                       f"Chart error: {e}")
+
+    def _render_chart(self, hist, ticker: str, chart_attr: str, parent: tk.Widget):
+        """Draw OHLCV chart inside parent with interactive crosshair tooltip."""
+        if not _MATPLOTLIB_OK:
+            return
+
+        # Destroy previous canvas
+        old = getattr(self, chart_attr, None)
+        if old is not None:
+            try:
+                old.get_tk_widget().destroy()
+            except Exception:
+                pass
+        # Hide placeholder
+        ph = getattr(self, chart_attr + "_placeholder", None)
+        if ph:
+            try:
+                ph.pack_forget()
+            except Exception:
+                pass
+
+        import pandas as pd
+        import numpy as np
+
+        close  = hist["Close"]
+        volume = hist["Volume"] if "Volume" in hist.columns else None
+        ma20   = close.rolling(20).mean() if len(close) >= 20 else None
+        ma50   = close.rolling(50).mean() if len(close) >= 50 else None
+
+        # Convert index to plain datetime for reliable hover snapping
+        dates = pd.to_datetime(close.index).tz_localize(None) if close.index.tz else pd.to_datetime(close.index)
+        prices = close.values
+
+        # Use the actual screen DPI so matplotlib's mouse-event coordinate
+        # system aligns with physical pixels reported by SetProcessDpiAwareness.
+        # Without this, event.inaxes is always None on high-DPI laptops and
+        # the hover info box never appears.
+        try:
+            _chart_dpi = max(72, min(300, int(parent.winfo_fpixels('1i'))))
+        except Exception:
+            _chart_dpi = 96
+        fig = Figure(figsize=(5, 3.8), dpi=_chart_dpi, facecolor=T["bg"])
+
+        if volume is not None:
+            ax_price  = fig.add_axes([0.09, 0.30, 0.87, 0.62], facecolor=T["bg"])
+            ax_volume = fig.add_axes([0.09, 0.06, 0.87, 0.20], facecolor=T["bg"],
+                                     sharex=ax_price)
+        else:
+            ax_price  = fig.add_axes([0.09, 0.08, 0.87, 0.86], facecolor=T["bg"])
+            ax_volume = None
+
+        # Price line
+        ax_price.plot(dates, prices, color=T["accent"], linewidth=1.6, label="Close")
+        if ma20 is not None:
+            ax_price.plot(dates, ma20.values, color="#ffd740",
+                          linewidth=1.0, linestyle="--", label="20-Day Moving Average")
+        if ma50 is not None:
+            ax_price.plot(dates, ma50.values, color="#888888",
+                          linewidth=1.0, linestyle="--", label="50-Day Moving Average")
+
+        ax_price.set_title(f"{ticker} — Price History", color=T["accent"],
+                           fontsize=10, pad=6)
+        ax_price.tick_params(colors=T["fg2"], labelsize=8)
+        for spine in ax_price.spines.values():
+            spine.set_edgecolor(T["border"])
+        ax_price.yaxis.label.set_color(T["fg2"])
+        ax_price.grid(color="#111111", linewidth=0.5, linestyle="-")
+        ax_price.legend(facecolor=T["bg"], edgecolor=T["border"],
+                        labelcolor=T["fg"], fontsize=8, loc="upper left")
+        ax_price.tick_params(axis="x", labelbottom=(ax_volume is None))
+
+        # Volume bars
+        if ax_volume is not None and volume is not None:
+            vol_dates = pd.to_datetime(volume.index).tz_localize(None) if volume.index.tz else pd.to_datetime(volume.index)
+            bar_colors = [T["green"] if i == 0 or prices[i] >= prices[i - 1]
+                          else T["red"] for i in range(len(prices))]
+            ax_volume.bar(vol_dates, volume.values, color=bar_colors,
+                          width=0.8, align="center")
+            ax_volume.tick_params(colors=T["fg2"], labelsize=7)
+            for spine in ax_volume.spines.values():
+                spine.set_edgecolor(T["border"])
+            ax_volume.yaxis.set_major_formatter(
+                mticker.FuncFormatter(
+                    lambda x, _: f"{x/1e6:.0f}M" if x >= 1e6 else f"{x/1e3:.0f}K"))
+            ax_volume.grid(color=T["border"], linewidth=0.4, linestyle="-")
+
+            # 20-day average volume for relative context in hover box
+            _vol_arr = volume.values.astype(float)
+            _kernel  = np.ones(20) / 20
+            _conv    = np.convolve(_vol_arr, _kernel, mode="full")[: len(_vol_arr)]
+            _conv[:19] = np.nan
+            vol_ma20_arr = _conv
+        else:
+            vol_ma20_arr = None
+
+        # Date formatting on x-axis
+        ax_bottom = ax_volume if ax_volume is not None else ax_price
+        try:
+            ax_bottom.xaxis.set_major_formatter(mdates.DateFormatter("%b '%y"))
+            ax_bottom.xaxis.set_major_locator(mdates.AutoDateLocator())
+        except Exception:
+            pass
+        for lbl in ax_bottom.get_xticklabels():
+            lbl.set_rotation(30)
+            lbl.set_ha("right")
+            lbl.set_color(T["fg2"])
+
+        # ── Crosshair elements ──────────────────────────────────────────
+        vline_p = ax_price.axvline(x=dates[0], color=T["fg2"],
+                                   linewidth=0.8, linestyle="--", visible=False)
+        hline_p = ax_price.axhline(y=prices[0], color=T["fg2"],
+                                   linewidth=0.8, linestyle="--", visible=False)
+        dot_p   = ax_price.plot([], [], "o", color=T["accent"],
+                                markersize=5, zorder=5)[0]
+
+        # Hover info box (top-right corner of price axes, inside the plot)
+        info_box = ax_price.text(
+            0.99, 0.97, "",
+            transform=ax_price.transAxes,
+            ha="right", va="top",
+            fontsize=8,
+            color=T["accent"],
+            bbox=dict(boxstyle="round,pad=0.4", facecolor=T["bg"],
+                      edgecolor=T["accent"], alpha=0.96),
+            visible=False,
+            zorder=10,
+        )
+
+        vline_v = (ax_volume.axvline(x=dates[0], color=T["fg2"],
+                                     linewidth=0.8, linestyle="--", visible=False)
+                   if ax_volume is not None else None)
+
+        hline_v = (ax_volume.axhline(y=0, color=T["fg2"],
+                                     linewidth=0.8, linestyle="--", visible=False)
+                   if ax_volume is not None else None)
+
+        # Hover info box for the volume panel (bottom-right corner)
+        info_box_v = (
+            ax_volume.text(
+                0.99, 0.97, "",
+                transform=ax_volume.transAxes,
+                ha="right", va="top",
+                fontsize=7.5,
+                color=T["accent"],
+                bbox=dict(boxstyle="round,pad=0.35", facecolor=T["bg"],
+                          edgecolor=T["accent"], alpha=0.96),
+                visible=False,
+                zorder=10,
+            ) if ax_volume is not None else None
+        )
+
+        # numeric date array for fast nearest-index search
+        date_nums = np.array([d.timestamp() for d in dates])
+
+        def _on_move(event):
+            # Only respond when cursor is inside the price or volume axes
+            if event.inaxes not in ([ax_price] + ([ax_volume] if ax_volume else [])):
+                vline_p.set_visible(False)
+                hline_p.set_visible(False)
+                dot_p.set_data([], [])
+                info_box.set_visible(False)
+                if vline_v:
+                    vline_v.set_visible(False)
+                if hline_v:
+                    hline_v.set_visible(False)
+                if info_box_v:
+                    info_box_v.set_visible(False)
+                try:
+                    canvas.draw_idle()
+                except Exception:
+                    pass
+                return
+
+            try:
+                # Snap to nearest data point
+                x_dt = mdates.num2date(event.xdata).replace(tzinfo=None)
+                ts   = x_dt.timestamp()
+                idx  = int(np.argmin(np.abs(date_nums - ts)))
+                snap_date  = dates[idx]
+                snap_price = prices[idx]
+                snap_x     = mdates.date2num(snap_date)
+
+                vline_p.set_xdata([snap_x, snap_x])
+                vline_p.set_visible(True)
+                hline_p.set_ydata([snap_price, snap_price])
+                hline_p.set_visible(True)
+                dot_p.set_data([snap_x], [snap_price])
+
+                # Daily % change vs previous close
+                if idx > 0:
+                    prev = prices[idx - 1]
+                    pct  = (snap_price - prev) / prev * 100 if prev != 0 else 0.0
+                    sign = "+" if pct >= 0 else ""
+                    chg_str = f"\nChange:  {sign}{pct:.2f}%"
+                else:
+                    pct     = None
+                    chg_str = ""
+
+                vol_str = ""
+                if volume is not None and idx < len(volume.values):
+                    v = volume.values[idx]
+                    vol_str = (f"\nVol:  {v/1e6:.2f}M" if v >= 1e6
+                               else f"\nVol:  {int(v):,}")
+
+                info_box.set_text(
+                    f"{snap_date.strftime('%b %d, %Y')}\n"
+                    f"Price:  ${snap_price:,.2f}"
+                    f"{chg_str}"
+                    f"{vol_str}"
+                )
+                info_box.set_visible(True)
+
+                if vline_v:
+                    vline_v.set_xdata([snap_x, snap_x])
+                    vline_v.set_visible(True)
+
+                # ── Volume panel hover info ────────────────────────────────
+                if (info_box_v is not None and volume is not None
+                        and idx < len(volume.values)):
+                    v = volume.values[idx]
+                    vol_fmt = (f"{v/1e6:.2f}M" if v >= 1e6 else f"{int(v):,}")
+
+                    # Buy / sell pressure label
+                    if pct is not None:
+                        if pct >= 0:
+                            direction = f"\u2191 Buying pressure   {pct:+.2f}%"
+                        else:
+                            direction = f"\u2193 Selling pressure  {pct:+.2f}%"
+                    else:
+                        direction = ""
+
+                    # Volume vs 20-day average
+                    avg_str = ""
+                    if vol_ma20_arr is not None and idx < len(vol_ma20_arr):
+                        avg = vol_ma20_arr[idx]
+                        if not np.isnan(avg) and avg > 0:
+                            ratio    = v / avg
+                            avg_fmt  = (f"{avg/1e6:.2f}M" if avg >= 1e6
+                                        else f"{int(avg):,}")
+                            avg_str  = f"\nvs 20D Avg:  {ratio:.2f}× ({avg_fmt})"
+
+                    info_box_v.set_text(
+                        f"{snap_date.strftime('%b %d, %Y')}\n"
+                        f"Volume:  {vol_fmt}"
+                        + (f"\n{direction}" if direction else "")
+                        + avg_str
+                    )
+                    info_box_v.set_visible(True)
+
+                    if hline_v:
+                        hline_v.set_ydata([v, v])
+                        hline_v.set_visible(True)
+                elif info_box_v is not None:
+                    info_box_v.set_visible(False)
+                    if hline_v:
+                        hline_v.set_visible(False)
+
+                canvas.draw_idle()
+            except Exception:
+                pass
+
+        def _on_leave(event):
+            vline_p.set_visible(False)
+            hline_p.set_visible(False)
+            dot_p.set_data([], [])
+            info_box.set_visible(False)
+            if vline_v:
+                vline_v.set_visible(False)
+            if hline_v:
+                hline_v.set_visible(False)
+            if info_box_v:
+                info_box_v.set_visible(False)
+            try:
+                canvas.draw_idle()
+            except Exception:
+                pass
+
+        try:
+            canvas = FigureCanvasTkAgg(fig, master=parent)
+            canvas.draw()
+            canvas.get_tk_widget().pack(fill="both", expand=True, padx=4, pady=(0, 4))
+            canvas.get_tk_widget().config(cursor="crosshair")
+            fig.canvas.mpl_connect("motion_notify_event", _on_move)
+            fig.canvas.mpl_connect("axes_leave_event",    _on_leave)
+            fig.canvas.mpl_connect("figure_leave_event",  _on_leave)
+            setattr(self, chart_attr, canvas)
+        except Exception as e:
+            self._set_chart_placeholder_text(chart_attr, f"Render error: {e}")
+
+    def _update_commentary(self, row):
+        """Generate and insert analyst commentary into the text box."""
+        box = self._commentary_box
+        box.configure(state="normal")
+        box.delete("1.0", "end")
+
+        def ins(text, tag="bullet"):
+            box.insert("end", text, tag)
+
+        ticker = row["ticker"]
+        name   = str(row.get("name", ticker))
+        sector = str(row.get("sector", "N/A"))
+        score  = row.get("composite_score")
+
+        # Trim longBusinessSummary to one tight paragraph
+        def _one_para(text, max_chars=480):
+            text = (text or "").strip()
+            if not text:
+                return ""
+            para = text.split("\n")[0].strip()
+            if len(para) <= max_chars:
+                return para
+            snippet  = para[:max_chars]
+            last_dot = snippet.rfind(". ")
+            return snippet[:last_dot + 1] if last_dot > max_chars // 3 else snippet.rstrip() + "…"
+
+        desc = _one_para(str(row.get("business_summary", "") or ""))
+
+        # ── SUMMARY ──────────────────────────────────────────────────────
+        ins("━" * 56 + "\n", "heading")
+        ins(" SUMMARY\n", "heading")
+        ins("━" * 56 + "\n", "heading")
+
+        if not _nan(score):
+            if   score >= 72: tier, tier_tag = "Strong Buy candidate",        "verdict_buy"
+            elif score >= 62: tier, tier_tag = "Buy / above-average opportunity", "verdict_buy"
+            elif score >= 52: tier, tier_tag = "Neutral — Hold / Watch",      "verdict_hold"
+            elif score >= 42: tier, tier_tag = "Underperform — caution advised","verdict_sell"
+            else:             tier, tier_tag = "Avoid — significant headwinds","verdict_sell"
+
+            ins(f"\n{name} ({ticker})\n", "heading")
+            ins(f"Sector: {sector}    ", "bullet")
+            ins(f"Composite Score: {score:.1f} / 100\n", "bullet")
+            ins(f"Verdict: ", "bullet")
+            ins(f"{tier}\n\n", tier_tag)
+        else:
+            ins(f"\n{name} ({ticker}) — {sector}\n", "heading")
+            ins("Insufficient data for full evaluation.\n\n", "neutral")
+
+        if desc:
+            ins(desc + "\n\n", "description")
+
+        # ── INVESTMENT THESIS ─────────────────────────────────────────────
+        ins("━" * 56 + "\n", "heading")
+        ins(" INVESTMENT THESIS\n", "heading")
+        ins("━" * 56 + "\n\n", "heading")
+
+        pe       = row.get("pe_forward") or row.get("pe_trailing")
+        rev_g    = row.get("revenue_growth")
+        earn_g   = row.get("earnings_growth")
+        roe      = row.get("roe")
+        pm       = row.get("profit_margin")
+        upside   = row.get("analyst_upside")
+        rec      = str(row.get("recommendation", ""))
+        ns       = row.get("news_sentiment")
+        r3       = row.get("ret_3m")
+        r6       = row.get("ret_6m")
+
+        sv = row.get("score_value",         50)
+        sg = row.get("score_growth",        50)
+        sm = row.get("score_momentum",      50)
+        sq = row.get("score_quality",       50)
+        sp = row.get("score_profitability", 50)
+        ss = row.get("score_sentiment",     50)
+        sa = row.get("score_analyst",       50)
+        sr = row.get("score_risk",          50)
+
+        strengths = []
+
+        if not _nan(sv) and sv >= 62:
+            pe_str = f" (P/E: {pe:.1f}x)" if not _nan(pe) and pe > 0 else ""
+            strengths.append(("positive",
+                f"Valuation: Trading at an attractive multiple relative to peers{pe_str}."))
+
+        if not _nan(sg) and sg >= 62:
+            g_parts = []
+            if not _nan(rev_g)  and rev_g  > 0.05: g_parts.append(f"revenue +{rev_g*100:.1f}%")
+            if not _nan(earn_g) and earn_g > 0.05: g_parts.append(f"earnings +{earn_g*100:.1f}%")
+            g_str = " (" + ", ".join(g_parts) + ")" if g_parts else ""
+            strengths.append(("positive", f"Growth: Strong fundamental growth trajectory{g_str}."))
+
+        if not _nan(sm) and sm >= 62:
+            m_parts = []
+            if not _nan(r3): m_parts.append(f"3M: {r3*100:+.1f}%")
+            if not _nan(r6): m_parts.append(f"6M: {r6*100:+.1f}%")
+            m_str = " (" + ", ".join(m_parts) + ")" if m_parts else ""
+            strengths.append(("positive", f"Momentum: Positive price trend relative to universe{m_str}."))
+
+        if not _nan(sq) and sq >= 62:
+            r_str = f" ROE: {roe*100:.1f}%." if not _nan(roe) else ""
+            strengths.append(("positive",
+                f"Quality: Strong balance sheet and capital efficiency.{r_str}"))
+
+        if not _nan(sp) and sp >= 62:
+            p_str = f" Net margin: {pm*100:.1f}%." if not _nan(pm) else ""
+            strengths.append(("positive", f"Profitability: High-quality earnings with strong margins.{p_str}"))
+
+        if not _nan(ss) and ss >= 62:
+            s_str = f" (score: {ns:+.3f})" if not _nan(ns) else ""
+            strengths.append(("positive", f"Sentiment: Recent news coverage is broadly positive{s_str}."))
+
+        if not _nan(sa) and sa >= 62:
+            parts = []
+            if rec and rec not in ("nan", "N/A"):
+                parts.append(rec.replace("_", " ").title())
+            if not _nan(upside) and upside > 0:
+                parts.append(f"{upside*100:.1f}% upside to consensus target")
+            a_str = " — " + ", ".join(parts) if parts else ""
+            strengths.append(("positive", f"Analyst Consensus: Bullish institutional view{a_str}."))
+
+        if not _nan(sr) and sr >= 62:
+            strengths.append(("positive",
+                "Risk Profile: Low short interest and stable volatility — favourable risk/reward."))
+
+        if strengths:
+            for tag, text in strengths:
+                ins(f"  ✔  {text}\n", tag)
+        else:
+            ins("  No strong positive catalysts identified at current levels.\n", "neutral")
+
+        ins("\n", "bullet")
+
+        # ── RISK FACTORS ──────────────────────────────────────────────────
+        ins("━" * 56 + "\n", "heading")
+        ins(" RISK FACTORS\n", "heading")
+        ins("━" * 56 + "\n\n", "heading")
+
+        short_pct = row.get("short_percent")
+        beta      = row.get("beta")
+        vol       = row.get("volatility_30d")
+        debt_eq   = row.get("debt_to_equity")
+        risks = []
+
+        if not _nan(sv) and sv <= 38:
+            pe_str = f" (P/E: {pe:.1f}x)" if not _nan(pe) and pe > 0 else ""
+            risks.append(("negative",
+                f"Valuation Risk: Elevated multiples relative to peers{pe_str}. Leaves little margin for error."))
+
+        if not _nan(sg) and sg <= 38:
+            risks.append(("negative",
+                "Growth Risk: Weak or decelerating growth may disappoint investors."))
+
+        if not _nan(sm) and sm <= 38:
+            m_parts = []
+            if not _nan(r3): m_parts.append(f"3M: {r3*100:+.1f}%")
+            if not _nan(r6): m_parts.append(f"6M: {r6*100:+.1f}%")
+            m_str = " (" + ", ".join(m_parts) + ")" if m_parts else ""
+            risks.append(("negative", f"Momentum Risk: Negative price trend{m_str}. Downtrend may continue."))
+
+        if not _nan(sq) and sq <= 38:
+            risks.append(("negative",
+                "Balance Sheet Risk: High leverage or weak liquidity could amplify downside."))
+
+        if not _nan(ss) and ss <= 38:
+            s_str = f" (score: {ns:+.3f})" if not _nan(ns) else ""
+            risks.append(("negative",
+                f"Sentiment Risk: Negative news flow may weigh on near-term price action{s_str}."))
+
+        if not _nan(sa) and sa <= 38:
+            r_str = rec.replace("_", " ").title() if rec and rec not in ("nan", "N/A") else ""
+            u_str = f" | {upside*100:.1f}% downside to target" if not _nan(upside) and upside < 0 else ""
+            risks.append(("negative",
+                f"Analyst Risk: Bearish institutional view. {r_str}{u_str}"))
+
+        if not _nan(short_pct) and short_pct > 0.08:
+            lvl = "Very high" if short_pct > 0.20 else "Elevated"
+            risks.append(("negative",
+                f"Short Interest: {lvl} at {short_pct*100:.1f}% of float — "
+                "signals institutional bearish conviction. Potential for forced selling."))
+
+        if not _nan(beta):
+            if beta > 1.8:
+                risks.append(("negative",
+                    f"Volatility Risk: High beta ({beta:.2f}x) significantly amplifies "
+                    "both market upside and downside moves."))
+            elif beta < 0:
+                risks.append(("negative",
+                    f"Unusual Beta: Negative beta ({beta:.2f}) — moves inversely to the "
+                    "market, which may not be suitable for all portfolios."))
+
+        if not _nan(vol) and vol > 0.40:
+            risks.append(("negative",
+                f"Volatility Risk: 30-day realised volatility of {vol*100:.1f}% (annualised) "
+                "is significantly above average."))
+
+        if not _nan(debt_eq) and debt_eq > 200:
+            risks.append(("negative",
+                f"Leverage Risk: Debt/equity ratio of {debt_eq:.0f}% indicates heavy debt load. "
+                "Rising interest rates or revenue shortfalls could strain cash flows."))
+
+        if risks:
+            for tag, text in risks:
+                ins(f"  ✘  {text}\n", tag)
+        else:
+            ins("  No major risk flags identified at this time.\n", "positive")
+
+        ins("\n", "bullet")
+
+        # ── ADDITIONAL CONTEXT ────────────────────────────────────────────
+        ins("━" * 56 + "\n", "heading")
+        ins(" ADDITIONAL CONTEXT\n", "heading")
+        ins("━" * 56 + "\n\n", "heading")
+
+        div   = row.get("dividend_yield")
+        curr  = row.get("current_ratio")
+        fcf   = row.get("fcf_yield")
+        price = row.get("price")
+        hi52  = row.get("52w_high")
+        lo52  = row.get("52w_low")
+
+        if not _nan(div) and div > 0:
+            ins(f"  •  Dividend yield of {div*100:.2f}% provides income support.\n", "positive")
+
+        if not _nan(curr) and curr >= 2.0:
+            ins(f"  •  Current ratio of {curr:.1f}x indicates strong short-term liquidity.\n", "positive")
+        elif not _nan(curr) and curr < 1.0:
+            ins(f"  •  Current ratio of {curr:.1f}x raises near-term liquidity concerns.\n", "negative")
+
+        if not _nan(fcf) and fcf > 0.03:
+            ins(f"  •  FCF yield of {fcf*100:.1f}% suggests the business generates "
+                "meaningful free cash flow relative to its market cap.\n", "positive")
+
+        if not _nan(price) and not _nan(hi52) and not _nan(lo52) and hi52 > lo52:
+            pct_from_high = (price - hi52) / hi52
+            pct_from_low  = (price - lo52) / lo52
+            ins(f"  •  Current price is {abs(pct_from_high)*100:.1f}% below 52-week high "
+                f"and {pct_from_low*100:.1f}% above 52-week low.\n", "bullet")
+
+        if not _nan(beta) and 0.7 <= beta <= 1.3:
+            ins(f"  •  Beta of {beta:.2f} closely tracks the broader market — suitable "
+                "for balanced portfolios.\n", "bullet")
+
+        ins("\n", "bullet")
+
+        # ── NEWS HIGHLIGHTS ───────────────────────────────────────────────
+        headlines = row.get("news_headlines") or []
+        if headlines:
+            ins("━" * 56 + "\n", "heading")
+            ins(" NEWS HIGHLIGHTS\n", "heading")
+            ins("━" * 56 + "\n\n", "heading")
+
+            def _classify(title):
+                t = title.lower()
+                if any(w in t for w in ["earn", "profit", "revenue", "eps", "beat",
+                                        "miss", "quarter", "guidance", "forecast",
+                                        "sales", "income", "margin"]):
+                    return "earnings"
+                if any(w in t for w in ["acqui", "merger", "deal", "buyout",
+                                        "takeover", "bid", "acquire"]):
+                    return "ma"
+                if any(w in t for w in ["partner", "contract", "agreement",
+                                        "launch", "expand", "open", "win"]):
+                    return "growth"
+                if any(w in t for w in ["upgrade", "downgrade", "target", "initiat",
+                                        "rating", "analyst", "overweight",
+                                        "underweight"]):
+                    return "analyst"
+                if any(w in t for w in ["lawsuit", "investig", "sec", "fine",
+                                        "penalty", "fraud", "violation",
+                                        "probe", "regulat", "recall"]):
+                    return "legal"
+                if any(w in t for w in ["layoff", "restructur", "closure",
+                                        "shut down", "dismissal", "job cut"]):
+                    return "restructuring"
+                if any(w in t for w in ["ceo", "cfo", "coo", "chief",
+                                        "executive", "appoint", "resign",
+                                        "depart", "hire", "leadership"]):
+                    return "leadership"
+                if any(w in t for w in ["dividend", "buyback", "repurchas",
+                                        "split", "special pay"]):
+                    return "shareholder"
+                if any(w in t for w in ["patent", "innovat", "product", "drug",
+                                        "trial", "fda", "approv", "launch",
+                                        "technolog", " ai "]):
+                    return "product"
+                return "general"
+
+            _IMPL = {
+                ("earnings",      True):  "Strong financials can support multiple expansion and analyst upgrades.",
+                ("earnings",      False): "Weak results or missed guidance may trigger near-term selling pressure.",
+                ("ma",            True):  "M&A activity can unlock value — watch for deal certainty and synergy capture.",
+                ("ma",            False): "Deal uncertainty or high premiums may weigh on near-term returns.",
+                ("growth",        True):  "Expansion signals may support long-term revenue growth and market share gains.",
+                ("growth",        False): "Setbacks in growth plans could delay targets and disappoint investors.",
+                ("analyst",       True):  "Analyst upgrades and raised price targets often attract institutional buying.",
+                ("analyst",       False): "Downgrades or reduced targets may reduce institutional demand.",
+                ("legal",         True):  "Positive legal resolution removes an investor overhang and may re-rate the stock.",
+                ("legal",         False): "Regulatory or legal headwinds can create lasting uncertainty and valuation pressure.",
+                ("restructuring", True):  "Cost reduction efforts can improve margins and free cash flow over time.",
+                ("restructuring", False): "Restructuring may signal operational challenges or weakening demand.",
+                ("leadership",    True):  "New leadership can bring strategic clarity and renewed investor confidence.",
+                ("leadership",    False): "Executive departures may signal internal issues or strategic uncertainty.",
+                ("shareholder",   True):  "Capital returns signal management confidence and can attract income investors.",
+                ("shareholder",   False): "Dividend cuts or suspension may indicate cash flow stress.",
+                ("product",       True):  "New products or approvals can open significant revenue opportunities.",
+                ("product",       False): "Product setbacks or failures may materially impact future revenue projections.",
+                ("general",       True):  "Positive market narrative may support near-term investor sentiment.",
+                ("general",       False): "Negative coverage can weigh on investor sentiment and short-term price action.",
+            }
+
+            def _trim_summary(text: str, title: str = "",
+                              max_sentences: int = 2) -> str:
+                """
+                Return up to max_sentences clean sentences from a summary string.
+                Strips residual HTML tags/entities and skips text that just
+                echoes the headline.
+                """
+                # Final-pass clean: unescape entities, strip tags, collapse spaces
+                text = _html.unescape(text or "")
+                text = re.sub(r'<[^>]+>', ' ', text)
+                text = re.sub(r'\s+', ' ', text).strip()
+                if not text:
+                    return ""
+                # Skip if the summary is just the headline repeated
+                if title:
+                    norm_title = re.sub(r'\W+', ' ', title.lower()).strip()
+                    norm_text  = re.sub(r'\W+', ' ', text.lower()).strip()
+                    if norm_text.startswith(norm_title[:50]) or \
+                       norm_title[:50] in norm_text[:len(norm_title) + 20]:
+                        return ""
+                parts = re.split(r'(?<=[.!?])\s+', text)
+                trimmed = " ".join(parts[:max_sentences]).strip()
+                if trimmed and trimmed[-1] not in ".!?":
+                    trimmed += "."
+                return trimmed
+
+            for idx, item in enumerate(headlines):
+                # Support both old 3-tuple and new 5-tuple format gracefully
+                if len(item) == 5:
+                    title, h_score, age_days, url, summary = item
+                else:
+                    title, h_score, age_days = item
+                    url, summary = "", ""
+
+                category = _classify(title)
+                if h_score >= 0.05:
+                    h_tag, h_label = "positive", "Positive"
+                    implication = _IMPL.get((category, True), _IMPL[("general", True)])
+                elif h_score <= -0.05:
+                    h_tag, h_label = "negative", "Negative"
+                    implication = _IMPL.get((category, False), _IMPL[("general", False)])
+                else:
+                    h_tag, h_label = "neutral", "Neutral"
+                    implication = "Neutral coverage — monitor for shifts in tone as the story develops."
+
+                # Precise relative time
+                age_hours = age_days * 24
+                age_mins  = age_days * 1440
+                if age_mins < 1:
+                    age_str = "Just now"
+                elif age_hours < 1:
+                    age_str = f"{int(age_mins)}m ago"
+                elif age_hours < 24:
+                    age_str = f"{int(age_hours)}h ago"
+                elif age_days < 2:
+                    age_str = "Yesterday"
+                else:
+                    age_str = f"{int(age_days)}d ago"
+
+                # Build 2-3 sentence recap: article summary + implication
+                short_summary = _trim_summary(summary, title=title, max_sentences=2)
+                if short_summary:
+                    recap = f"{short_summary} {implication}"
+                else:
+                    recap = implication
+
+                ins(f"  [{h_label}]  ", h_tag)
+                # Headline — hyperlinked if a URL is available
+                if url:
+                    link_tag = f"_newslink_{idx}"
+                    box.tag_configure(link_tag,
+                                      foreground=T["accent"],
+                                      underline=True,
+                                      font=("Segoe UI", 10))
+                    box.tag_bind(link_tag, "<Enter>",
+                                 lambda e, b=box: b.config(cursor="hand2"))
+                    box.tag_bind(link_tag, "<Leave>",
+                                 lambda e, b=box: b.config(cursor=""))
+                    box.tag_bind(link_tag, "<Button-1>",
+                                 lambda e, u=url: webbrowser.open(u))
+                    box.insert("end", f"{title}\n", ("bullet", link_tag))
+                else:
+                    ins(f"{title}\n", "bullet")
+                ins(f"  {age_str}  ·  {recap}\n\n", "dim")
+
+        ins("\n", "bullet")
+
+        # ── RECOMMENDATION ────────────────────────────────────────────────
+        ins("━" * 56 + "\n", "heading")
+        ins(" RECOMMENDATION\n", "heading")
+        ins("━" * 56 + "\n\n", "heading")
+
+        # Derive recommendation and timeframe from the data
+        n_strengths = len(strengths)
+        n_risks     = len(risks)
+
+        # Determine investment timeframe based on dominant factor pattern
+        hi_mom    = not _nan(sm)  and sm  >= 65
+        hi_val    = not _nan(sv)  and sv  >= 65
+        hi_qual   = not _nan(sq)  and sq  >= 65
+        hi_growth = not _nan(sg)  and sg  >= 65
+        hi_short  = not _nan(row.get("short_percent")) and (row.get("short_percent") or 0) > 0.15
+        hi_vol    = not _nan(vol)  and (vol  or 0) > 0.50
+
+        if not _nan(score):
+            if score >= 72 and n_strengths >= 3 and n_risks == 0:
+                rec_label   = "STRONG BUY"
+                rec_tag     = "verdict_buy"
+                if hi_val and hi_qual:
+                    timeframe = "12–36 months (fundamental thesis)"
+                    tf_reason = "Strong valuation discount and balance sheet quality support a longer holding period."
+                elif hi_mom:
+                    timeframe = "3–12 months (momentum-driven)"
+                    tf_reason = "Price trend is strong — re-evaluate if momentum fades."
+                else:
+                    timeframe = "6–18 months"
+                    tf_reason = "Multiple factors aligned. Monitor quarterly earnings for confirmation."
+
+            elif score >= 62 and n_strengths >= 2:
+                rec_label   = "BUY"
+                rec_tag     = "verdict_buy"
+                if hi_val and not hi_mom:
+                    timeframe = "12–24 months (value unlock)"
+                    tf_reason = "Undervalued on fundamentals — patience required for market to re-rate."
+                elif hi_mom and not hi_val:
+                    timeframe = "1–6 months (trend play)"
+                    tf_reason = "Momentum-driven opportunity. Set a stop-loss and monitor price action."
+                elif hi_growth:
+                    timeframe = "6–18 months (growth compounding)"
+                    tf_reason = "Strong growth trajectory. Suitable while earnings acceleration continues."
+                else:
+                    timeframe = "6–12 months"
+                    tf_reason = "Favorable setup. Review if fundamentals or sentiment deteriorate."
+
+            elif score >= 52:
+                rec_label   = "HOLD / WATCH"
+                rec_tag     = "verdict_hold"
+                timeframe   = "Reassess in 1–3 months"
+                tf_reason   = "Mixed signals. No compelling entry at current levels — monitor for improvement."
+
+            elif score >= 42:
+                rec_label   = "UNDERPERFORM"
+                rec_tag     = "verdict_sell"
+                timeframe   = "Avoid new positions"
+                tf_reason   = "Below-average score with notable risk factors. Wait for a clearer signal."
+
+            else:
+                rec_label   = "AVOID"
+                rec_tag     = "verdict_sell"
+                timeframe   = "Do not initiate"
+                tf_reason   = "Significant headwinds across multiple factors. Risk outweighs reward."
+
+            # Override with caution flags
+            if hi_short:
+                rec_label = f"{rec_label} — CAUTION (High Short Interest)"
+                rec_tag   = "verdict_sell" if rec_tag == "verdict_hold" else rec_tag
+                tf_reason += " High short interest warns of institutional bearish conviction."
+            if hi_vol:
+                tf_reason += " Elevated volatility increases risk; size positions accordingly."
+
+            ins(f"  Verdict:    ", "bullet")
+            ins(f"{rec_label}\n", rec_tag)
+            ins(f"  Timeframe:  {timeframe}\n", "bullet")
+            ins(f"\n  Reasoning:  {tf_reason}\n", "neutral")
+
+            # Key supporting metrics
+            ins("\n  Key metrics driving this view:\n", "bullet")
+            metric_lines = []
+            if not _nan(sv):
+                metric_lines.append(f"  • Value score {sv:.0f}/100" +
+                    (f" — P/E {pe:.1f}x" if not _nan(pe) and pe > 0 else ""))
+            if not _nan(sg):
+                metric_lines.append(f"  • Growth score {sg:.0f}/100" +
+                    (f" — Rev growth {rev_g*100:+.1f}%" if not _nan(rev_g) else ""))
+            if not _nan(sm):
+                metric_lines.append(f"  • Momentum score {sm:.0f}/100" +
+                    (f" — 6M return {r6*100:+.1f}%" if not _nan(r6) else ""))
+            if not _nan(sa):
+                metric_lines.append(f"  • Analyst score {sa:.0f}/100" +
+                    (f" — {upside*100:.1f}% upside to target" if not _nan(upside) and upside > 0 else ""))
+            for ml in metric_lines:
+                ins(ml + "\n", "bullet")
+        else:
+            ins("  Insufficient data to generate a recommendation.\n", "neutral")
+
+        ins("\n", "bullet")
+
+        # ── DISCLAIMER ────────────────────────────────────────────────────
+        ins("─" * 56 + "\n", "dim")
+        ins("This commentary is generated algorithmically from public market data.\n"
+            "It is for informational purposes only and does not constitute financial\n"
+            "advice. Always conduct your own due diligence before investing.\n", "dim")
+
+        box.configure(state="disabled")
+
+    # ------------------------------------------------------------------ #
+    # Field definitions                                                    #
+    # ------------------------------------------------------------------ #
+
+    _SCORE_FIELDS = [
+        ("Composite Score",  "composite_score"),
+        ("Value",            "score_value"),
+        ("Growth",           "score_growth"),
+        ("Momentum",         "score_momentum"),
+        ("Quality",          "score_quality"),
+        ("Profitability",    "score_profitability"),
+        ("Sentiment",        "score_sentiment"),
+        ("Analyst",          "score_analyst"),
+        ("Risk",             "score_risk"),
+    ]
+    _VAL_FIELDS = [
+        ("Price",            "price"),
+        ("Market Cap",       "market_cap"),
+        ("P/E Forward",      "pe_forward"),
+        ("P/E Trailing",     "pe_trailing"),
+        ("P/B Ratio",        "pb_ratio"),
+        ("Book Value",       "book_value"),
+        ("EV / EBITDA",      "ev_ebitda"),
+        ("52W High",         "52w_high"),
+        ("52W Low",          "52w_low"),
+    ]
+    _GROWTH_FIELDS = [
+        ("Revenue Growth",   "revenue_growth"),
+        ("Earnings Growth",  "earnings_growth"),
+        ("EPS Forward",      "eps_forward"),
+        ("EPS Trailing",     "eps_trailing"),
+    ]
+    _MOM_FIELDS = [
+        ("1-Month Return",   "ret_1m"),
+        ("3-Month Return",   "ret_3m"),
+        ("6-Month Return",   "ret_6m"),
+        ("12-Month Return",  "ret_12m"),
+    ]
+    _QUAL_FIELDS = [
+        ("Revenue",          "_revenue_fmt"),
+        ("Net Income",       "_net_income_fmt"),
+        ("Operating Income", "_op_income_fmt"),
+        ("ROE",              "roe"),
+        ("ROA",              "roa"),
+        ("Total Debt",       "total_debt"),
+        ("Total Equity",     "_equity_fmt"),
+        ("Total Cash",       "total_cash"),
+        ("Current Ratio",    "current_ratio"),
+        ("Profit Margin",    "_profit_margin_fmt"),
+        ("Operating Margin", "_op_margin_fmt"),
+        ("FCF Yield",        "fcf_yield"),
+        ("Dividend Yield",   "dividend_yield"),
+    ]
+    _ANLST_FIELDS = [
+        ("Recommendation",   "recommendation"),
+        ("# Analysts",       "analyst_count"),
+        ("Price Target",     "analyst_target"),
+        ("Upside to Target", "analyst_upside"),
+        ("News Sentiment",   "news_sentiment"),
+        ("Short Interest",   "short_percent"),
+        ("Beta",             "beta"),
+        ("30D Volatility",   "volatility_30d"),
+    ]
+
+    # ------------------------------------------------------------------ #
+    # Detail update                                                        #
+    # ------------------------------------------------------------------ #
+
+    def _update_detail(self, row):
+        ticker = row["ticker"]
+        name   = str(row.get("name", ticker))
+        sector = str(row.get("sector", "N/A"))
+        self._detail_title.config(
+            text=f"  {ticker}  —  {name}    ·    {sector}",
+            fg=T["fg"])
+
+        # Derived: balance sheet figures
+        total_debt = row.get("total_debt")
+        total_cash = row.get("total_cash")
+        de_ratio   = row.get("debt_to_equity")
+        revenue    = row.get("revenue")
+        pm         = row.get("profit_margin")
+        om         = row.get("operating_margin")
+
+        # Total Equity (derived from debt and D/E ratio)
+        if not _nan(total_debt) and not _nan(de_ratio) and de_ratio != 0:
+            _equity_val = total_debt / (de_ratio / 100.0)
+            equity_fmt  = _mcap(_equity_val)
+        else:
+            equity_fmt  = "—"
+
+        # Revenue
+        revenue_fmt = _mcap(revenue) if not _nan(revenue) else "—"
+
+        # Net Income = Revenue × Profit Margin
+        if not _nan(revenue) and not _nan(pm):
+            net_income_fmt = _mcap(revenue * pm)
+        else:
+            net_income_fmt = "—"
+
+        # Operating Income = Revenue × Operating Margin
+        if not _nan(revenue) and not _nan(om):
+            op_income_fmt = _mcap(revenue * om)
+        else:
+            op_income_fmt = "—"
+
+        # Profit Margin: percent + dollar equivalent
+        if not _nan(pm):
+            _pm_pct = f"{pm * 100:.1f}%"
+            profit_margin_fmt = (f"{_pm_pct}  ({_mcap(revenue * pm)})"
+                                 if not _nan(revenue) else _pm_pct)
+        else:
+            profit_margin_fmt = "—"
+
+        # Operating Margin: percent + dollar equivalent
+        if not _nan(om):
+            _om_pct = f"{om * 100:.1f}%"
+            op_margin_fmt = (f"{_om_pct}  ({_mcap(revenue * om)})"
+                             if not _nan(revenue) else _om_pct)
+        else:
+            op_margin_fmt = "—"
+
+        # Derived: Sentiment label
+        ns = row.get("news_sentiment")
+        if _nan(ns):
+            sentiment_fmt = "— (no data)"
+        elif ns >= 0.05:
+            sentiment_fmt = f"Positive  ({ns:+.3f})"
+        elif ns <= -0.05:
+            sentiment_fmt = f"Negative  ({ns:+.3f})"
+        else:
+            sentiment_fmt = f"Neutral  ({ns:+.3f})"
+
+        _derived = {
+            "_revenue_fmt":       revenue_fmt,
+            "_net_income_fmt":    net_income_fmt,
+            "_op_income_fmt":     op_income_fmt,
+            "_equity_fmt":        equity_fmt,
+            "_profit_margin_fmt": profit_margin_fmt,
+            "_op_margin_fmt":     op_margin_fmt,
+        }
+
+        def _rec_fmt(v):
+            return "—" if not v or str(v) in ("nan", "N/A", "None") \
+                else str(v).replace("_", " ").title()
+
+        def _count_fmt(v):
+            return "—" if _nan(v) else str(int(v))
+
+        _FORMATTERS = {
+            "composite_score":    lambda v: _score(v) + " / 100",
+            "score_value":        lambda v: _score(v) + " / 100",
+            "score_growth":       lambda v: _score(v) + " / 100",
+            "score_momentum":     lambda v: _score(v) + " / 100",
+            "score_quality":      lambda v: _score(v) + " / 100",
+            "score_profitability":lambda v: _score(v) + " / 100",
+            "score_sentiment":    lambda v: _score(v) + " / 100",
+            "score_analyst":      lambda v: _score(v) + " / 100",
+            "score_risk":         lambda v: _score(v) + " / 100",
+            "price":              _price,
+            "market_cap":         _mcap,
+            "pe_forward":         _flt,
+            "pe_trailing":        _flt,
+            "pb_ratio":           _flt,
+            "book_value":         _price,
+            "ev_ebitda":          _flt,
+            "52w_high":           _price,
+            "52w_low":            _price,
+            "revenue_growth":     _pct,
+            "earnings_growth":    _pct,
+            "eps_forward":        _flt,
+            "eps_trailing":       _flt,
+            "ret_1m":             _pct,
+            "ret_3m":             _pct,
+            "ret_6m":             _pct,
+            "ret_12m":            _pct,
+            "roe":                _pct,
+            "roa":                _pct,
+            "total_debt":         _mcap,
+            "total_cash":         _mcap,
+            "_equity_fmt":        lambda v: v or "—",
+            "_revenue_fmt":       lambda v: v or "—",
+            "_net_income_fmt":    lambda v: v or "—",
+            "_op_income_fmt":     lambda v: v or "—",
+            "_profit_margin_fmt": lambda v: v or "—",
+            "_op_margin_fmt":     lambda v: v or "—",
+            "current_ratio":      _flt,
+            "profit_margin":      _pct,
+            "operating_margin":   _pct,
+            "fcf_yield":          _pct,
+            "dividend_yield":     _pct,
+            "recommendation":     _rec_fmt,
+            "analyst_count":      _count_fmt,
+            "analyst_target":     _price,
+            "analyst_upside":     _pct,
+            "news_sentiment":     lambda v: sentiment_fmt,
+            "short_percent":      _pct,
+            "beta":               _flt,
+            "volatility_30d":     _pct,
+        }
+
+        _GREEN_KEYS = {
+            "ret_1m", "ret_3m", "ret_6m", "ret_12m", "revenue_growth",
+            "earnings_growth", "roe", "roa", "profit_margin",
+            "operating_margin", "fcf_yield", "analyst_upside", "dividend_yield",
+        }
+
+        for key, lbl in self._detail_labels.items():
+            fmt = _FORMATTERS.get(key, lambda v: _flt(v))
+            val = _derived.get(key, row.get(key))
+            text = fmt(val)
+            fg = T["fg"]
+            if key in _GREEN_KEYS and not _nan(val):
+                fg = T["green"] if val >= 0 else T["red"]
+            elif key == "news_sentiment" and not _nan(ns):
+                fg = T["green"] if ns >= 0.05 else (T["red"] if ns <= -0.05 else T["yellow"])
+            elif key in ("short_percent", "volatility_30d") and not _nan(val):
+                fg = T["red"] if val > 0.10 else T["green"]
+            elif key == "total_debt" and not _nan(val):
+                fg = T["red"] if val > 0 else T["fg"]
+            elif key == "total_cash" and not _nan(val):
+                fg = T["green"] if val > 0 else T["fg"]
+            elif key == "_net_income_fmt" and not _nan(pm):
+                fg = T["green"] if pm >= 0 else T["red"]
+            elif key == "_op_income_fmt" and not _nan(om):
+                fg = T["green"] if om >= 0 else T["red"]
+            elif key == "_profit_margin_fmt" and not _nan(pm):
+                fg = T["green"] if pm >= 0 else T["red"]
+            elif key == "_op_margin_fmt" and not _nan(om):
+                fg = T["green"] if om >= 0 else T["red"]
+            lbl.config(text=text, fg=fg)
+
+        self._update_score_bars(row)
+        self._update_commentary(row)
+
+        # Trigger chart update when ticker changes
+        new_ticker = row["ticker"]
+        if new_ticker != self._chart_ticker:
+            self._chart_ticker = new_ticker
+            period = self._chart_period.get()
+            threading.Thread(
+                target=self._fetch_and_render_chart,
+                args=(new_ticker, period, "_chart_canvas", self._chart_parent_frame),
+                daemon=True,
+            ).start()
+
+    # ------------------------------------------------------------------ #
+    # Status bar                                                           #
+    # ------------------------------------------------------------------ #
+
+    def _get_tooltip_text(self, label: str) -> str:
+        """Return tooltip text for a metric label.
+        For Composite Score the formula weights reflect the current strategy."""
+        if label == "Composite Score":
+            strategy = self._strategy_var.get()
+            if strategy == "Custom..." and self._custom_weights:
+                w = self._custom_weights
+            elif strategy in STRATEGY_PRESETS:
+                w = STRATEGY_PRESETS[strategy]
+            else:
+                w = WEIGHTS
+            return (
+                "Weighted average of all 8 factor scores (each ranked 0–100 across "
+                "all screened stocks).\n\n"
+                f"Formula  [{strategy}]:\n"
+                f"  {w['value']*100:.0f}% × Value\n"
+                f"  {w['growth']*100:.0f}% × Growth\n"
+                f"  {w['momentum']*100:.0f}% × Momentum\n"
+                f"  {w['quality']*100:.0f}% × Quality\n"
+                f"  {w['profitability']*100:.0f}% × Profitability\n"
+                f"  {w['sentiment']*100:.0f}% × Sentiment\n"
+                f"  {w['analyst']*100:.0f}% × Analyst\n"
+                f"  {w['risk']*100:.0f}% × Risk"
+            )
+        return _METRIC_TOOLTIPS.get(label, "")
+
+    def _open_custom_strategy_dialog(self):
+        """Open a dialog for the user to define custom factor weights."""
+        # Revert combobox to previous selection if user cancels
+        prev_strategy = next(
+            (s for s in list(STRATEGY_PRESETS.keys()) + ["Custom..."]
+             if self._df_raw is None or s == "Custom..."),
+            "Balanced (Default)"
+        )
+
+        dlg = tk.Toplevel(self)
+        dlg.title("Custom Strategy Weights")
+        dlg.configure(bg=T["bg"])
+        dlg.resizable(False, False)
+        dlg.grab_set()
+
+        FACTORS = [
+            ("value",         "Value"),
+            ("growth",        "Growth"),
+            ("momentum",      "Momentum"),
+            ("quality",       "Quality"),
+            ("profitability", "Profitability"),
+            ("sentiment",     "Sentiment"),
+            ("analyst",       "Analyst"),
+            ("risk",          "Risk"),
+        ]
+
+        # Use existing custom weights or the current preset as starting point
+        strategy = next(
+            (s for s in STRATEGY_PRESETS if s == self._strategy_var.get()),
+            "Balanced (Default)"
+        )
+        base = self._custom_weights or STRATEGY_PRESETS.get(strategy, WEIGHTS)
+
+        tk.Label(dlg, text="Set factor weights (must sum to 100%)",
+                 bg=T["bg"], fg=T["accent"], font=T["font_sec"],
+                 pady=10).grid(row=0, column=0, columnspan=3, padx=16)
+
+        vars_: dict[str, tk.StringVar] = {}
+        for i, (key, lbl) in enumerate(FACTORS, start=1):
+            tk.Label(dlg, text=lbl, bg=T["bg"], fg=T["fg2"],
+                     font=T["font_small"], width=14, anchor="w"
+                     ).grid(row=i, column=0, padx=(16, 4), pady=3, sticky="w")
+            v = tk.StringVar(value=f"{base[key] * 100:.1f}")
+            _PillEntry(dlg, v, width_chars=7, height=26
+                       ).grid(row=i, column=1, padx=(0, 2), pady=3)
+            tk.Label(dlg, text="%", bg=T["bg"], fg=T["accent"],
+                     font=T["font_small"]).grid(row=i, column=2, sticky="w")
+            vars_[key] = v
+
+        sum_var = tk.StringVar(value="Sum: 100.0%")
+        sum_lbl = tk.Label(dlg, textvariable=sum_var, bg=T["bg"],
+                           fg=T["accent"], font=T["font_small"])
+        sum_lbl.grid(row=len(FACTORS) + 1, column=0, columnspan=3, pady=(8, 0))
+
+        def _update_sum(*_):
+            total = 0.0
+            for v in vars_.values():
+                try: total += float(v.get())
+                except ValueError: pass
+            color = T["accent"] if abs(total - 100) < 0.5 else T["red"]
+            sum_var.set(f"Sum: {total:.1f}%")
+            sum_lbl.configure(fg=color)
+
+        for v in vars_.values():
+            v.trace_add("write", _update_sum)
+
+        def _apply():
+            w: dict[str, float] = {}
+            for key, v in vars_.items():
+                try:
+                    w[key] = float(v.get()) / 100.0
+                except ValueError:
+                    return  # invalid input — do nothing
+            total = sum(w.values())
+            if total <= 0:
+                return
+            # Normalise so weights always sum to exactly 1.0
+            w = {k: val / total for k, val in w.items()}
+            self._custom_weights = w
+            self._strategy_var.set("Custom...")
+            dlg.destroy()
+            if self._df_raw is not None:
+                self._df = score_stocks(self._df_raw, weights=w)
+                self._apply_filters()
+                self._status_var.set(
+                    f"  Strategy: Custom — rescored {len(self._df)} stocks.")
+
+        def _cancel():
+            # Restore combobox to what it was before opening the dialog
+            if self._custom_weights:
+                self._strategy_var.set("Custom...")
+            else:
+                self._strategy_var.set("Balanced (Default)")
+            dlg.destroy()
+
+        btn_frame = tk.Frame(dlg, bg=T["bg"])
+        btn_frame.grid(row=len(FACTORS) + 2, column=0, columnspan=3, pady=(_s(12), _s(16)))
+        _RoundedButton(btn_frame, "Apply", _apply, width=_s(90), height=_s(32),
+                       radius=_s(8)).pack(side="left", padx=_s(4))
+        _RoundedButton(btn_frame, "Cancel", _cancel, width=_s(90), height=_s(32),
+                       radius=_s(8)).pack(side="left", padx=_s(4))
+
+        dlg.protocol("WM_DELETE_WINDOW", _cancel)
+        dlg.update_idletasks()
+        px = self.winfo_x() + (self.winfo_width()  - dlg.winfo_reqwidth())  // 2
+        py = self.winfo_y() + (self.winfo_height() - dlg.winfo_reqheight()) // 2
+        dlg.geometry(f"+{px}+{py}")
+
+    def _show_info_popup(self, widget, text):
+        """Show a small info popup near the clicked (i) button."""
+        if self._info_popup is not None:
+            try:
+                self._info_popup.destroy()
+            except tk.TclError:
+                pass
+            self._info_popup = None
+
+        popup = tk.Toplevel(self)
+        self._info_popup = popup
+        popup.overrideredirect(True)
+        popup.configure(bg=T["bg3"])
+
+        sw = self.winfo_screenwidth()
+        sh = self.winfo_screenheight()
+        # Max popup width = 40% of screen; compute wraplength from that
+        max_popup_w = int(sw * 0.40)
+        wrap_px = max_popup_w - 28   # subtract padx margins
+
+        # Count visible lines to set height dynamically
+        _font_spec = ("Segoe UI", 9)
+        lines = text.split("\n")
+        # Estimate wrapped line count
+        char_px = 6  # ~6px per char at 9pt Segoe UI
+        n_lines = sum(
+            max(1, int(len(l) * char_px / wrap_px) + 1) if l.strip() else 1
+            for l in lines
+        )
+        n_lines = max(4, min(n_lines, int(sh * 0.55 / 18)))  # cap height
+
+        txt = tk.Text(
+            popup,
+            bg=T["bg3"], fg=T["fg"],
+            font=_font_spec,
+            wrap="word",
+            relief="flat", bd=0,
+            padx=12, pady=8,
+            highlightthickness=0,
+            state="normal", cursor="arrow",
+            width=wrap_px // char_px,
+            height=n_lines,
+        )
+        txt.insert("1.0", text)
+        txt.configure(state="disabled")
+        txt.pack()
+
+        popup.update_idletasks()
+        pw = popup.winfo_reqwidth()
+        ph = popup.winfo_reqheight()
+        rx = widget.winfo_rootx()
+        ry = widget.winfo_rooty() + widget.winfo_height() + 4
+        if rx + pw > sw - 10:
+            rx = sw - pw - 10
+        if ry + ph > sh - 10:
+            ry = widget.winfo_rooty() - ph - 4
+        popup.geometry(f"+{rx}+{ry}")
+        popup.lift()
+
+        def _close(e=None):
+            try:
+                popup.destroy()
+            except tk.TclError:
+                pass
+            self._info_popup = None
+
+        popup.bind("<FocusOut>", _close)
+        popup.bind("<Button-1>", _close)
+        for child in popup.winfo_children():
+            child.bind("<Button-1>", _close)
+        popup.focus_set()
+
+    # ------------------------------------------------------------------ #
+    # Status bar                                                           #
+    # ------------------------------------------------------------------ #
+
+    def _build_status_bar(self):
+        tk.Frame(self, bg=T["border"], height=1).pack(fill="x", side="bottom")
+        bar = tk.Frame(self, bg=T["bg"], pady=4)
+        bar.pack(fill="x", side="bottom")
+        self._status_var = tk.StringVar(value="Ready  —  press Run to start a scan")
+        tk.Label(bar, textvariable=self._status_var,
+                 bg=T["bg"], fg=T["fg2"], font=("Segoe UI", 9),
+                 anchor="w", padx=12).pack(side="left")
+
+    # ------------------------------------------------------------------ #
+    # Event handlers                                                       #
+    # ------------------------------------------------------------------ #
+
+    def _on_row_select(self, _event=None):
+        sel = self._tree.selection()
+        if not sel or self._df is None:
+            return
+        ticker = self._tree.item(sel[0], "values")[1]
+        match  = self._df[self._df["ticker"] == ticker]
+        if not match.empty:
+            self._selected_ticker = ticker
+            self._notebook.pack(fill="both", expand=True, padx=0, pady=0)
+            self._update_detail(match.iloc[0])
+
+    def _on_run(self):
+        self._run_id += 1
+        self._stop_event.clear()
+        self._run_btn.set_state("disabled")
+        self._stop_btn.set_state("normal")
+        self._progress_var.set(0)
+        self._status_var.set("Starting…")
+        strategy = self._strategy_var.get()
+        if strategy == "Custom..." and self._custom_weights:
+            run_weights = self._custom_weights
+        else:
+            run_weights = STRATEGY_PRESETS.get(strategy)   # None = default WEIGHTS
+
+        # ── Build screen-time filters from the current UI state ───────────
+        sector_filter = _SECTOR_FILTER_MAP.get(self._sector_var.get())  # None = all
+
+        mktcap_cat   = self._filter_mktcap.get()
+        mktcap_range = None
+        if mktcap_cat.startswith("Mega"):
+            mktcap_range = (100e9, None)
+        elif mktcap_cat.startswith("Large"):
+            mktcap_range = (10e9, 100e9)
+        elif mktcap_cat.startswith("Mid"):
+            mktcap_range = (2e9, 10e9)
+        elif mktcap_cat.startswith("Small"):
+            mktcap_range = (None, 2e9)
+
+        screen_filters = {
+            "sector_filter": sector_filter,
+            "mktcap_range":  mktcap_range,
+        }
+
+        settings = {
+            "top_n":           self._get_top_n(),
+            "workers":         10,
+            "index":           self._index_var.get(),
+            "weights":         run_weights,
+            "screen_filters":  screen_filters,
+        }
+        threading.Thread(target=self._worker, args=(settings, self._run_id), daemon=True).start()
+
+    def _on_stop(self):
+        self._stop_event.set()
+        self._run_id += 1          # invalidate any queued messages from the current worker
+        # drain any already-queued messages so stale progress/done don't appear
+        while not self._q.empty():
+            try:
+                self._q.get_nowait()
+            except queue.Empty:
+                break
+        # reset UI immediately — don't wait for the worker to check the stop flag
+        self._run_btn.set_state("normal")
+        self._stop_btn.set_state("disabled")
+        self._progress_var.set(0)
+        self._status_var.set("  Stopped.")
+
+    # ------------------------------------------------------------------ #
+    # Worker thread                                                        #
+    # ------------------------------------------------------------------ #
+
+    def _worker(self, settings: dict, run_id: int):
+        redirector = _StdoutRedirector(self._q, run_id)
+        old_stdout = sys.stdout
+        sys.stdout = redirector
+        try:
+            self._q.put({"type": "status", "run_id": run_id, "text": "Fetching ticker lists…"})
+            tickers = collect_tickers(index=settings["index"])
+            if not tickers:
+                self._q.put({"type": "error", "run_id": run_id,
+                             "text": "Could not retrieve any ticker lists."})
+                return
+            if self._stop_event.is_set():
+                self._q.put({"type": "stopped", "run_id": run_id})
+                return
+
+            sf     = settings.get("screen_filters", {})
+            parts  = []
+            idx_lbl = settings.get("index", "All")
+            if idx_lbl and idx_lbl != "All":
+                parts.append(idx_lbl)
+            if sf.get("sector_filter"):
+                parts.append(sf["sector_filter"][1])
+            if sf.get("mktcap_range"):
+                lo, hi = sf["mktcap_range"]
+                if lo and hi:
+                    parts.append(f"${int(lo//1e9)}B–${int(hi//1e9)}B")
+                elif lo:
+                    parts.append(f">${int(lo//1e9)}B")
+                elif hi:
+                    parts.append(f"<${int(hi//1e9)}B")
+            label = " · ".join(parts)
+            status_txt = f"Screening {len(tickers)} stocks" + (f" ({label})" if label else "") + "…"
+            self._q.put({"type": "status", "run_id": run_id, "text": status_txt})
+            df_raw = fetch_all(tickers, max_workers=settings["workers"],
+                               screen_filters=sf)
+
+            if self._stop_event.is_set():
+                self._q.put({"type": "stopped", "run_id": run_id})
+                return
+            if df_raw.empty:
+                self._q.put({"type": "error", "run_id": run_id,
+                             "text": "No data returned from yfinance."})
+                return
+
+            self._q.put({"type": "status", "run_id": run_id,
+                         "text": f"Computing scores for {len(df_raw)} stocks…"})
+            df_scored  = score_stocks(df_raw, weights=settings.get("weights"))
+            self._q.put({"type": "done", "run_id": run_id,
+                         "df_raw":    df_raw,
+                         "df_scored": df_scored,
+                         "total_scored": len(df_scored)})
+        except Exception as exc:
+            self._q.put({"type": "error", "run_id": run_id, "text": str(exc)})
+        finally:
+            sys.stdout = old_stdout
+
+    # ------------------------------------------------------------------ #
+    # Queue polling                                                        #
+    # ------------------------------------------------------------------ #
+
+    def _poll_queue(self):
+        try:
+            while True:
+                msg   = self._q.get_nowait()
+                # discard messages from a previously-stopped run
+                if msg.get("run_id") != self._run_id:
+                    continue
+                mtype = msg["type"]
+
+                if mtype == "progress":
+                    total = msg["total"]
+                    if total:
+                        self._progress_var.set(msg["done"] / total * 100)
+                    self._status_var.set(
+                        f"  {msg['done']}/{total}   ok={msg['ok']}   "
+                        f"skip={msg['skip']}   ETA {msg['eta']:.0f}s")
+
+                elif mtype == "status":
+                    self._status_var.set("  " + msg["text"])
+
+                elif mtype == "done":
+                    self._df_raw = msg["df_raw"]
+                    self._df     = msg["df_scored"]
+                    self._progress_var.set(100)
+                    n = msg["total_scored"]
+                    self._status_var.set(
+                        f"  Done — {n} stocks scored. Applying filters…")
+                    self._apply_filters()
+                    from datetime import datetime
+                    self._lastrun_var.set(
+                        "Last run: " + datetime.now().strftime("%H:%M:%S"))
+                    self._run_btn.set_state("normal")
+                    self._stop_btn.set_state("disabled")
+                    break
+
+                elif mtype in ("error", "stopped"):
+                    self._status_var.set("  " + msg.get("text", "Stopped."))
+                    self._progress_var.set(0)
+                    self._run_btn.set_state("normal")
+                    self._stop_btn.set_state("disabled")
+                    break
+
+        except queue.Empty:
+            pass
+
+        self.after(100, self._poll_queue)
+
+    # ------------------------------------------------------------------ #
+    # Stock lookup window                                                  #
+    # ------------------------------------------------------------------ #
+
+    def _open_lookup_window(self, _event=None):
+        _StockLookupWindow(self, df=self._df)
+
+
+# ---------------------------------------------------------------------------
+# Stock Lookup Window
+# ---------------------------------------------------------------------------
+
+class _StockLookupWindow(tk.Toplevel):
+    """
+    Independent stock search window.
+    Accepts a ticker symbol or company name, checks loaded screener data first,
+    then fetches live from yfinance.  Displays the full detail panel + chart.
+    """
+
+    _SCORE_FIELDS = ScreenerApp._SCORE_FIELDS if hasattr(ScreenerApp, "_SCORE_FIELDS") else []
+    _VAL_FIELDS   = ScreenerApp._VAL_FIELDS   if hasattr(ScreenerApp, "_VAL_FIELDS")   else []
+    _GROWTH_FIELDS= ScreenerApp._GROWTH_FIELDS if hasattr(ScreenerApp, "_GROWTH_FIELDS") else []
+    _MOM_FIELDS   = ScreenerApp._MOM_FIELDS   if hasattr(ScreenerApp, "_MOM_FIELDS")   else []
+    _QUAL_FIELDS  = ScreenerApp._QUAL_FIELDS  if hasattr(ScreenerApp, "_QUAL_FIELDS")  else []
+    _ANLST_FIELDS = ScreenerApp._ANLST_FIELDS if hasattr(ScreenerApp, "_ANLST_FIELDS") else []
+
+    def __init__(self, parent, df=None):
+        super().__init__(parent)
+        self.title(f"{_APP_NAME} — Stock Lookup")
+        self.configure(bg=T["bg"])
+        # Size the window to fit any screen: cap at 90 % of screen dimensions
+        # so the chart at the bottom is always fully visible.
+        sw = self.winfo_screenwidth()
+        sh = self.winfo_screenheight()
+        w  = min(_s(820), int(sw * 0.90))
+        h  = min(_s(940), int(sh * 0.90))
+        self.geometry(f"{w}x{h}")
+        self.minsize(_s(700), _s(550))
+        self.resizable(True, True)
+        self._df = df          # loaded screener DataFrame (may be None)
+        self._detail_labels: dict = {}
+        self._score_bars: dict    = {}
+        self._chart_ticker  = None
+        self._chart_canvas  = None
+        self._info_popup    = None
+
+        self._build_search_bar()
+        self._build_detail_panel()
+        self.grab_set()
+
+    # ---- Search bar -------------------------------------------------------
+
+    def _build_search_bar(self):
+        outer = tk.Frame(self, bg=T["bg"])
+        outer.pack(fill="x", side="top")
+        bar = tk.Frame(outer, bg=T["bg"], pady=_s(10))
+        bar.pack(fill="x", padx=_s(14))
+        tk.Frame(outer, bg=T["border"], height=1).pack(fill="x")
+
+        tk.Label(bar, text="  Ticker / Company:", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+
+        self._search_var = tk.StringVar()
+        _se = _PillEntry(bar, self._search_var, width_chars=22, height=32)
+        _se.pack(side="left", padx=_s(6))
+        _se.entry.bind("<Return>", lambda _e: self._do_search())
+        _se.entry.focus_set()
+
+        _RoundedButton(bar, "Search", self._do_search,
+                       width=_s(80), height=_s(30), radius=_s(8)
+                       ).pack(side="left", padx=(0, _s(8)))
+
+        self._search_status = tk.StringVar(value="")
+        tk.Label(bar, textvariable=self._search_status,
+                 bg=T["bg"], fg=T["fg2"], font=T["font_small"]).pack(side="left", padx=8)
+
+    # ---- Detail panel (mirrors ScreenerApp) --------------------------------
+
+    def _build_detail_panel(self):
+        panel = tk.Frame(self, bg=T["bg"])
+        panel.pack(fill="both", expand=True)
+
+        self._detail_title = tk.Label(
+            panel,
+            text="  Enter a ticker symbol or company name above",
+            bg=T["bg"], fg=T["fg2"], font=T["font_head"],
+            anchor="w", pady=8, padx=12)
+        self._detail_title.pack(fill="x", side="top")
+        tk.Frame(panel, bg=T["border"], height=1).pack(fill="x")
+
+        self._notebook = _CustomNotebook(panel)
+        self._notebook.pack(fill="both", expand=True)
+
+        # Scores tab — animated bar widgets
+        scores_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(scores_tab, text="  Scores  ")
+        self._build_scores_tab_content(scores_tab)
+
+        for title, fields in [
+            ("Valuation",        self._VAL_FIELDS),
+            ("Growth",           self._GROWTH_FIELDS),
+            ("Momentum",         self._MOM_FIELDS),
+            ("Quality & Profit", self._QUAL_FIELDS),
+        ]:
+            tab = tk.Frame(self._notebook, bg=T["bg"])
+            self._notebook.add(tab, text=f"  {title}  ")
+            labels = self._build_tab_content(tab, fields)
+            self._detail_labels.update(labels)
+
+        # Analyst tab — full version with metrics + commentary
+        analyst_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(analyst_tab, text="  Analyst  ")
+        self._build_analyst_tab(analyst_tab)
+
+        # Chart tab
+        chart_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(chart_tab, text="  Chart  ")
+        self._chart_period = tk.StringVar(value="6mo")
+        self._chart_parent_frame = chart_tab
+        self._build_chart_tab_simple(chart_tab)
+
+    def _build_chart_tab_simple(self, parent):
+        """Minimal chart tab for the lookup window."""
+        ctrl = tk.Frame(parent, bg=T["bg"])
+        ctrl.pack(fill="x", side="top")
+        tk.Frame(ctrl, bg=T["bg"], width=12).pack(side="left")
+        for val, lbl in [("1mo","1M"),("3mo","3M"),("6mo","6M"),
+                          ("1y","1Y"),("2y","2Y"),("5y","5Y")]:
+            b = tk.Radiobutton(
+                ctrl, text=lbl, variable=self._chart_period, value=val,
+                bg=T["bg"], fg=T["fg2"], selectcolor=T["accent"],
+                activebackground=T["bg"], activeforeground=T["accent"],
+                font=("Segoe UI", 9, "bold"), indicatoron=False,
+                relief="flat", overrelief="flat", padx=10, pady=5, bd=0,
+                cursor="hand2",
+                command=self._refresh_chart,
+            )
+            b.pack(side="left", padx=1, pady=(4, 0))
+        tk.Frame(ctrl, bg=T["border"], height=1).pack(fill="x", side="bottom")
+
+        self._chart_canvas_placeholder = tk.Label(
+            parent,
+            text="Search for a stock to view its price chart.",
+            bg=T["bg"], fg=T["fg2"], font=T["font_small"],
+        )
+        self._chart_canvas_placeholder.pack(expand=True)
+
+    def _refresh_chart(self):
+        if self._chart_ticker:
+            threading.Thread(
+                target=self._fetch_and_render_chart,
+                args=(self._chart_ticker, self._chart_period.get(),
+                      "_chart_canvas", self._chart_parent_frame),
+                daemon=True,
+            ).start()
+
+    # Delegate shared rendering logic from ScreenerApp
+    _build_tab_content          = ScreenerApp._build_tab_content
+    _build_scores_tab_content   = ScreenerApp._build_scores_tab_content
+    _update_score_bars          = ScreenerApp._update_score_bars
+    _build_analyst_tab          = ScreenerApp._build_analyst_tab
+    _update_commentary          = ScreenerApp._update_commentary
+    _show_info_popup            = ScreenerApp._show_info_popup
+    _fetch_and_render_chart     = ScreenerApp._fetch_and_render_chart
+    _render_chart               = ScreenerApp._render_chart
+    _set_chart_placeholder_text = ScreenerApp._set_chart_placeholder_text
+
+    def _get_tooltip_text(self, label: str) -> str:
+        """Static tooltip lookup — no strategy context in the lookup window."""
+        return _METRIC_TOOLTIPS.get(label, "")
+
+    # ---- Search logic -------------------------------------------------------
+
+    def _do_search(self):
+        query = self._search_var.get().strip().lstrip("$")
+        if not query:
+            return
+        self._search_status.set("Searching…")
+        self.update_idletasks()
+        threading.Thread(target=self._search_worker, args=(query,), daemon=True).start()
+
+    def _search_worker(self, query: str):
+        row = self._find_in_df(query)
+        if row is not None:
+            self.after(0, self._populate, row, f"Found in screener data: {row['ticker']}")
+            return
+        # Live fetch from yfinance
+        live_row = self._fetch_live(query)
+        if live_row is not None:
+            self.after(0, self._populate, live_row, f"Live data: {live_row['ticker']}")
+        else:
+            self.after(0, self._search_status.set,
+                       f"No results for '{query}'. Try the exact ticker symbol.")
+
+    def _find_in_df(self, query: str):
+        """Check loaded DataFrame for ticker or name match."""
+        if self._df is None or self._df.empty:
+            return None
+        import pandas as pd
+        q = query.upper().strip().lstrip("$")
+        # Ticker exact match
+        mask = self._df["ticker"].str.upper() == q
+        if mask.any():
+            return self._df[mask].iloc[0]
+        # Name partial match (case-insensitive)
+        if "name" in self._df.columns:
+            mask2 = self._df["name"].str.upper().str.contains(q, regex=False, na=False)
+            if mask2.any():
+                return self._df[mask2].iloc[0]
+        return None
+
+    def _fetch_live(self, query: str):
+        """Fetch a single ticker live from yfinance and build a row dict."""
+        if not _YF_OK:
+            return None
+        import pandas as pd
+        ticker = query.upper().strip().lstrip("$")
+        try:
+            stock = yf.Ticker(ticker)
+            info  = stock.info
+            if not info or not isinstance(info, dict) or len(info) < 3:
+                # Try searching by name via yfinance search
+                try:
+                    results = yf.Search(query, max_results=1)
+                    quotes  = getattr(results, "quotes", [])
+                    if quotes:
+                        ticker = quotes[0].get("symbol", ticker)
+                        stock  = yf.Ticker(ticker)
+                        info   = stock.info
+                except Exception:
+                    pass
+            if not info or not isinstance(info, dict) or len(info) < 3:
+                return None
+
+            # Build a minimal row compatible with _update_detail
+            def _g(k, default=None):
+                v = info.get(k, default)
+                return v if v not in (None, "N/A", "", "None") else default
+
+            hist   = stock.history(period="1y", auto_adjust=True)
+            close  = hist["Close"].dropna() if not hist.empty else pd.Series(dtype=float)
+            price  = close.iloc[-1] if not close.empty else _g("regularMarketPrice")
+            ret_1m = (close.iloc[-1] / close.iloc[-22] - 1) if len(close) >= 22 else None
+            ret_3m = (close.iloc[-1] / close.iloc[-66] - 1) if len(close) >= 66 else None
+            ret_6m = (close.iloc[-1] / close.iloc[-130] - 1) if len(close) >= 130 else None
+            ret_12m= (close.iloc[-1] / close.iloc[0]   - 1) if len(close) >= 2  else None
+
+            _company_name = _g("longName") or _g("shortName") or ""
+            try:
+                _news_agg, _news_headlines = get_news_headlines(
+                    stock, ticker=ticker, company_name=_company_name)
+            except Exception:
+                _news_agg, _news_headlines = None, []
+
+            row = {
+                "ticker":           ticker,
+                "name":             _g("longName") or _g("shortName") or ticker,
+                "sector":           _g("sector", "N/A"),
+                "industry":         _g("industry", "N/A"),
+                "price":            price,
+                "market_cap":       _g("marketCap"),
+                "pe_forward":       _g("forwardPE"),
+                "pe_trailing":      _g("trailingPE"),
+                "pb_ratio":         _g("priceToBook"),
+                "book_value":       _g("bookValue"),
+                "ev_ebitda":        _g("enterpriseToEbitda"),
+                "52w_high":         _g("fiftyTwoWeekHigh"),
+                "52w_low":          _g("fiftyTwoWeekLow"),
+                "revenue_growth":   _g("revenueGrowth"),
+                "earnings_growth":  _g("earningsGrowth"),
+                "eps_forward":      _g("forwardEps"),
+                "eps_trailing":     _g("trailingEps"),
+                "ret_1m":           ret_1m,
+                "ret_3m":           ret_3m,
+                "ret_6m":           ret_6m,
+                "ret_12m":          ret_12m,
+                "roe":              _g("returnOnEquity"),
+                "roa":              _g("returnOnAssets"),
+                "total_debt":       _g("totalDebt"),
+                "debt_to_equity":   _g("debtToEquity"),
+                "total_cash":       _g("totalCash"),
+                "current_ratio":    _g("currentRatio"),
+                "revenue":          _g("totalRevenue"),
+                "profit_margin":    _g("profitMargins"),
+                "operating_margin": _g("operatingMargins"),
+                "fcf_yield":        None,
+                "dividend_yield":   _g("dividendYield"),
+                "recommendation":   _g("recommendationKey"),
+                "analyst_count":    _g("numberOfAnalystOpinions"),
+                "analyst_target":   _g("targetMeanPrice"),
+                "analyst_upside":   (((_g("targetMeanPrice") or 0) / price - 1)
+                                     if price and price > 0 and _g("targetMeanPrice")
+                                     else None),
+                "analyst_norm":     (
+                                     (5.0 - float(info["recommendationMean"])) / 4.0
+                                     if info.get("recommendationMean") is not None
+                                        and 1 <= float(info["recommendationMean"]) <= 5
+                                     else None
+                                    ),
+                "news_sentiment":   _news_agg,
+                "news_headlines":  _news_headlines,
+                "short_percent":    _g("shortPercentOfFloat"),
+                "beta":             _g("beta"),
+                "volatility_30d":   None,
+                # Scores not available for live lookup
+                "composite_score":  None,
+                "score_value":      None,
+                "score_growth":     None,
+                "score_momentum":   None,
+                "score_quality":    None,
+                "score_profitability": None,
+                "score_sentiment":  None,
+                "score_analyst":    None,
+                "score_risk":       None,
+                "business_summary": _g("longBusinessSummary", "") or "",
+            }
+            return row
+        except Exception:
+            return None
+
+    def _populate(self, row, status_msg: str):
+        """Populate the detail panel with data from a row dict or Series."""
+        import pandas as pd
+        if isinstance(row, pd.Series):
+            row = row.to_dict()
+
+        self._search_status.set(status_msg)
+        ticker = row.get("ticker", "?")
+        name   = str(row.get("name", ticker))
+        sector = str(row.get("sector", "N/A"))
+        self._detail_title.config(
+            text=f"  {ticker}  —  {name}    ·    {sector}", fg=T["fg"])
+
+        # Derived fields
+        total_debt = row.get("total_debt")
+        total_cash = row.get("total_cash")
+        de_ratio   = row.get("debt_to_equity")
+        revenue    = row.get("revenue")
+        pm         = row.get("profit_margin")
+        om         = row.get("operating_margin")
+
+        # Total Equity
+        if not _nan(total_debt) and not _nan(de_ratio) and de_ratio != 0:
+            row["_equity_fmt"] = _mcap(total_debt / (de_ratio / 100.0))
+        else:
+            row["_equity_fmt"] = "—"
+
+        # Revenue, Net Income, Operating Income
+        row["_revenue_fmt"]    = _mcap(revenue) if not _nan(revenue) else "—"
+        row["_net_income_fmt"] = (_mcap(revenue * pm)
+                                  if not _nan(revenue) and not _nan(pm) else "—")
+        row["_op_income_fmt"]  = (_mcap(revenue * om)
+                                  if not _nan(revenue) and not _nan(om) else "—")
+
+        # Profit Margin: percent + dollar
+        if not _nan(pm):
+            _pm_pct = f"{pm * 100:.1f}%"
+            row["_profit_margin_fmt"] = (f"{_pm_pct}  ({_mcap(revenue * pm)})"
+                                         if not _nan(revenue) else _pm_pct)
+        else:
+            row["_profit_margin_fmt"] = "—"
+
+        # Operating Margin: percent + dollar
+        if not _nan(om):
+            _om_pct = f"{om * 100:.1f}%"
+            row["_op_margin_fmt"] = (f"{_om_pct}  ({_mcap(revenue * om)})"
+                                     if not _nan(revenue) else _om_pct)
+        else:
+            row["_op_margin_fmt"] = "—"
+
+        ns = row.get("news_sentiment")
+        if _nan(ns):
+            row["_sentiment_fmt"] = "— (no data)"
+        elif ns >= 0.05:
+            row["_sentiment_fmt"] = f"Positive  ({ns:+.3f})"
+        elif ns <= -0.05:
+            row["_sentiment_fmt"] = f"Negative  ({ns:+.3f})"
+        else:
+            row["_sentiment_fmt"] = f"Neutral  ({ns:+.3f})"
+
+        _FORMATTERS = {
+            "composite_score":    lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_value":        lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_growth":       lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_momentum":     lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_quality":      lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_profitability":lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_sentiment":    lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_analyst":      lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "score_risk":         lambda v: _score(v) + " / 100" if not _nan(v) else "—",
+            "price":              _price,
+            "market_cap":         _mcap,
+            "pe_forward":         _flt,
+            "pe_trailing":        _flt,
+            "pb_ratio":           _flt,
+            "book_value":         _price,
+            "ev_ebitda":          _flt,
+            "52w_high":           _price,
+            "52w_low":            _price,
+            "revenue_growth":     _pct,
+            "earnings_growth":    _pct,
+            "eps_forward":        _flt,
+            "eps_trailing":       _flt,
+            "ret_1m":             _pct,
+            "ret_3m":             _pct,
+            "ret_6m":             _pct,
+            "ret_12m":            _pct,
+            "roe":                _pct,
+            "roa":                _pct,
+            "total_debt":         _mcap,
+            "total_cash":         _mcap,
+            "_equity_fmt":        lambda v: v or "—",
+            "_revenue_fmt":       lambda v: v or "—",
+            "_net_income_fmt":    lambda v: v or "—",
+            "_op_income_fmt":     lambda v: v or "—",
+            "_profit_margin_fmt": lambda v: v or "—",
+            "_op_margin_fmt":     lambda v: v or "—",
+            "current_ratio":      _flt,
+            "profit_margin":      _pct,
+            "operating_margin":   _pct,
+            "fcf_yield":          _pct,
+            "dividend_yield":     _pct,
+            "recommendation":     lambda v: ("—" if not v or str(v) in ("nan","N/A","None")
+                                             else str(v).replace("_"," ").title()),
+            "analyst_count":      lambda v: "—" if _nan(v) else str(int(v)),
+            "analyst_target":     _price,
+            "analyst_upside":     _pct,
+            "news_sentiment":     lambda v: row.get("_sentiment_fmt", "—"),
+            "short_percent":      _pct,
+            "beta":               _flt,
+            "volatility_30d":     _pct,
+        }
+
+        _GREEN_KEYS = {
+            "ret_1m", "ret_3m", "ret_6m", "ret_12m", "revenue_growth",
+            "earnings_growth", "roe", "roa", "profit_margin",
+            "operating_margin", "fcf_yield", "analyst_upside", "dividend_yield",
+        }
+
+        for key, lbl in self._detail_labels.items():
+            fmt  = _FORMATTERS.get(key, lambda v: _flt(v))
+            val  = row.get(key)
+            text = fmt(val)
+            fg   = T["fg"]
+            if key in _GREEN_KEYS and not _nan(val):
+                fg = T["green"] if val >= 0 else T["red"]
+            elif key == "news_sentiment" and not _nan(ns):
+                fg = T["green"] if ns >= 0.05 else (T["red"] if ns <= -0.05 else T["yellow"])
+            elif key in ("short_percent", "volatility_30d") and not _nan(val):
+                fg = T["red"] if val > 0.10 else T["green"]
+            elif key == "total_debt" and not _nan(val):
+                fg = T["red"] if val > 0 else T["fg"]
+            elif key == "total_cash" and not _nan(val):
+                fg = T["green"] if val > 0 else T["fg"]
+            elif key == "_net_income_fmt" and not _nan(pm):
+                fg = T["green"] if pm >= 0 else T["red"]
+            elif key == "_op_income_fmt" and not _nan(om):
+                fg = T["green"] if om >= 0 else T["red"]
+            elif key == "_profit_margin_fmt" and not _nan(pm):
+                fg = T["green"] if pm >= 0 else T["red"]
+            elif key == "_op_margin_fmt" and not _nan(om):
+                fg = T["green"] if om >= 0 else T["red"]
+            lbl.config(text=text, fg=fg)
+
+        self._update_score_bars(row)
+        # Analyst commentary
+        self._update_commentary(row)
+
+        # Trigger chart
+        new_ticker = row.get("ticker")
+        if new_ticker and new_ticker != self._chart_ticker:
+            self._chart_ticker = new_ticker
+            threading.Thread(
+                target=self._fetch_and_render_chart,
+                args=(new_ticker, self._chart_period.get(),
+                      "_chart_canvas", self._chart_parent_frame),
+                daemon=True,
+            ).start()
+
+
+# ---------------------------------------------------------------------------
+# Rounded UI helpers
+# ---------------------------------------------------------------------------
+
+def _pill_pts(w, h, r=10):
+    """Polygon points for a rounded rectangle (pill shape)."""
+    return [r,0, w-r,0, w,0, w,r, w,h-r, w,h, w-r,h, r,h, 0,h, 0,h-r, 0,r, 0,0]
+
+
+class _RoundedDropdown(tk.Canvas):
+    """
+    Pill-shaped dropdown matching the _RoundedButton tab style.
+    Solid green fill, black text, no border. Opens a styled tk.Menu on click.
+    Pass on_change=callable to be notified when the selection changes.
+    """
+    def __init__(self, parent, textvariable, values,
+                 width=140, height=30, radius=8,
+                 bg=None, fg="#000000", on_change=None, tooltips=None, **kw):
+        if bg is None:
+            bg = T["accent"]
+        try:
+            parent_bg = parent.cget("bg")
+        except Exception:
+            parent_bg = T["bg"]
+        super().__init__(parent, width=width, height=height,
+                         highlightthickness=0, bd=0, bg=parent_bg, **kw)
+        self._bg        = bg
+        self._fg        = fg
+        self._var       = textvariable
+        self._values    = list(values)
+        self._on_change = on_change
+        self._tooltips  = tooltips
+        self._dim_w     = width
+        self._dim_h     = height
+
+        pts = _pill_pts(width, height, radius)
+        self._rect = self.create_polygon(pts, smooth=1,
+                                          fill=bg, outline=bg, width=0)
+        # Value label (left-aligned)
+        self._lbl = self.create_text(_s(12), height // 2,
+                                      text=self._trunc(textvariable.get()),
+                                      fill=fg, font=("Segoe UI", 10),
+                                      anchor="w")
+        # Dropdown arrow (right-aligned)
+        self._arw = self.create_text(width - _s(10), height // 2,
+                                      text="▾", fill=fg,
+                                      font=("Segoe UI", 9, "bold"),
+                                      anchor="e")
+        self.config(cursor="hand2")
+        self.bind("<Button-1>", self._open)
+        self.bind("<Enter>",    self._on_enter)
+        self.bind("<Leave>",    self._on_leave)
+        textvariable.trace_add("write", self._sync)
+
+    def _trunc(self, val):
+        max_ch = max(3, (self._dim_w - _s(32)) // max(1, _s(7)))
+        return val[:max_ch] + "…" if len(val) > max_ch else val
+
+    def _sync(self, *_):
+        try:
+            self.itemconfig(self._lbl, text=self._trunc(self._var.get()))
+        except tk.TclError:
+            pass
+
+    def _on_enter(self, _e=None):
+        self.itemconfig(self._rect, fill="#00c060")
+
+    def _on_leave(self, _e=None):
+        self.itemconfig(self._rect, fill=self._bg)
+
+    def _open(self, event=None):
+        if self._tooltips:
+            self._open_tooltip_popup()
+        else:
+            self._open_plain_menu()
+
+    def _open_plain_menu(self):
+        popup = tk.Toplevel(self)
+        popup.overrideredirect(True)
+        popup.configure(bg="#0d0d0d")
+        popup.wm_attributes("-topmost", True)
+
+        tk.Frame(popup, bg=T["border"], height=1).pack(fill="x")
+
+        for val in self._values:
+            lbl = tk.Label(popup, text=val,
+                           bg="#0d0d0d", fg=T["fg"],
+                           font=("Segoe UI", 10),
+                           padx=14, pady=7, anchor="w", cursor="hand2",
+                           width=max(self._dim_w // _s(7), 8))
+            lbl.pack(fill="x")
+            tk.Frame(popup, bg=T["border"], height=1).pack(fill="x")
+
+            def _enter(e, l=lbl):
+                l.configure(bg=T["accent"], fg="#000000")
+
+            def _leave(e, l=lbl):
+                l.configure(bg="#0d0d0d", fg=T["fg"])
+
+            def _click(e, v=val):
+                try:
+                    popup.grab_release()
+                    popup.destroy()
+                except Exception:
+                    pass
+                self._pick(v)
+
+            lbl.bind("<Enter>", _enter)
+            lbl.bind("<Leave>", _leave)
+            lbl.bind("<Button-1>", _click)
+
+        popup.update_idletasks()
+        rx = self.winfo_rootx()
+        ry = self.winfo_rooty() + self._dim_h
+        sw = popup.winfo_screenwidth()
+        sh = popup.winfo_screenheight()
+        pw = popup.winfo_reqwidth()
+        ph = popup.winfo_reqheight()
+        px = min(rx, sw - pw - 4)
+        py = min(ry, sh - ph - 4)
+        popup.geometry(f"+{px}+{py}")
+        popup.grab_set()
+        popup.focus_set()
+
+        def _check_outside(e):
+            try:
+                ex, ey = e.x_root, e.y_root
+                px2 = popup.winfo_x(); py2 = popup.winfo_y()
+                pw2 = popup.winfo_width(); ph2 = popup.winfo_height()
+                if not (px2 <= ex <= px2 + pw2 and py2 <= ey <= py2 + ph2):
+                    popup.grab_release()
+                    popup.destroy()
+            except Exception:
+                pass
+
+        popup.bind("<Button-1>", _check_outside, add="+")
+        popup.bind("<Escape>", lambda e: [popup.grab_release(), popup.destroy()])
+
+    def _open_tooltip_popup(self):
+        popup = tk.Toplevel(self)
+        popup.overrideredirect(True)
+        popup.configure(bg=T["border"])
+        popup.wm_attributes("-topmost", True)
+
+        inner = tk.Frame(popup, bg="#0d0d0d")
+        inner.pack(padx=1, pady=1)
+
+        item_col = tk.Frame(inner, bg="#0d0d0d")
+        item_col.pack(side="left", fill="y")
+
+        tk.Frame(inner, bg=T["border"], width=1).pack(side="left", fill="y")
+
+        tip_col = tk.Frame(inner, bg=T["bg3"], width=270)
+        tip_col.pack(side="left", fill="y")
+        tip_col.pack_propagate(False)
+
+        tk.Label(tip_col, text="Strategy Info", bg=T["bg3"], fg=T["accent"],
+                 font=("Segoe UI", 9, "bold"),
+                 padx=10, pady=6, anchor="w").pack(fill="x")
+        tk.Frame(tip_col, bg=T["border"], height=1).pack(fill="x")
+
+        tip_body = tk.Label(tip_col,
+                            text="Hover over a strategy\nto see its description.",
+                            bg=T["bg3"], fg=T["fg2"],
+                            font=("Segoe UI", 9), wraplength=250,
+                            justify="left", padx=10, pady=8, anchor="nw")
+        tip_body.pack(fill="both", expand=True)
+
+        tk.Frame(item_col, bg=T["border"], height=1).pack(fill="x")
+
+        for val in self._values:
+            lbl = tk.Label(item_col, text=val,
+                           bg="#0d0d0d", fg=T["fg"],
+                           font=("Segoe UI", 10),
+                           padx=14, pady=7, anchor="w", cursor="hand2")
+            lbl.pack(fill="x")
+            tk.Frame(item_col, bg=T["border"], height=1).pack(fill="x")
+
+            def _enter(e, v=val, l=lbl):
+                l.configure(bg=T["accent"], fg="#000000")
+                tip_body.configure(text=(self._tooltips or {}).get(v, ""))
+
+            def _leave(e, l=lbl):
+                l.configure(bg="#0d0d0d", fg=T["fg"])
+
+            def _click(e, v=val):
+                try:
+                    popup.grab_release()
+                    popup.destroy()
+                except Exception:
+                    pass
+                self._pick(v)
+
+            lbl.bind("<Enter>", _enter)
+            lbl.bind("<Leave>", _leave)
+            lbl.bind("<Button-1>", _click)
+
+        popup.update_idletasks()
+        rx = self.winfo_rootx()
+        ry = self.winfo_rooty() + self._dim_h
+        sw = popup.winfo_screenwidth()
+        sh = popup.winfo_screenheight()
+        pw = popup.winfo_reqwidth()
+        ph = popup.winfo_reqheight()
+        px = min(rx, sw - pw - 4)
+        py = min(ry, sh - ph - 4)
+        popup.geometry(f"+{px}+{py}")
+        popup.grab_set()
+        popup.focus_set()
+
+        def _check_outside(e):
+            try:
+                ex, ey = e.x_root, e.y_root
+                px2 = popup.winfo_x(); py2 = popup.winfo_y()
+                pw2 = popup.winfo_width(); ph2 = popup.winfo_height()
+                if not (px2 <= ex <= px2 + pw2 and py2 <= ey <= py2 + ph2):
+                    popup.grab_release()
+                    popup.destroy()
+            except Exception:
+                pass
+
+        popup.bind("<Button-1>", _check_outside, add="+")
+        popup.bind("<Escape>", lambda e: [popup.grab_release(), popup.destroy()])
+
+    def _pick(self, val):
+        self._var.set(val)
+        if self._on_change:
+            self._on_change()
+
+    def update_values(self, new_values):
+        self._values = list(new_values)
+
+
+class _PillEntry(tk.Frame):
+    """
+    Compact pill-shaped entry matching the green-pill style.
+    `entry` attribute exposes the inner tk.Entry for event binding.
+    """
+    def __init__(self, parent, textvariable, width_chars=10, height=28,
+                 radius=None, **kw):
+        try:
+            parent_bg = parent.cget("bg")
+        except Exception:
+            parent_bg = T["bg"]
+        super().__init__(parent, bg=parent_bg, bd=0,
+                         highlightthickness=0, **kw)
+        char_px = _s(7)
+        px_w    = width_chars * char_px + _s(20)
+        px_h    = _s(height)
+        if radius is None:
+            radius = px_h // 2
+
+        cv = tk.Canvas(self, width=px_w, height=px_h,
+                       highlightthickness=0, bd=0, bg=parent_bg)
+        cv.pack()
+        pts = _pill_pts(px_w, px_h, radius)
+        cv.create_polygon(pts, smooth=1,
+                          fill=T["accent"], outline=T["accent"], width=0)
+        inner = tk.Frame(cv, bg=T["accent"], bd=0, highlightthickness=0)
+        cv.create_window(px_w // 2, px_h // 2, window=inner,
+                         width=px_w - _s(8), height=px_h - _s(6))
+        self.entry = tk.Entry(
+            inner, textvariable=textvariable, width=width_chars,
+            bg=T["accent"], fg="#000000", insertbackground="#000000",
+            font=T["font_small"], relief="flat", bd=0,
+            highlightthickness=0,
+        )
+        self.entry.pack(fill="x", expand=True, padx=4)
+
+
+class _RoundedButton(tk.Canvas):
+    """A canvas-drawn button with rounded corners. Supports set_state / set_active."""
+    def __init__(self, parent, text, command, width=110, height=36,
+                 bg=T["accent"], fg="#000000", border=None, radius=10, **kw):
+        super().__init__(parent, width=width, height=height,
+                         highlightthickness=0, bd=0,
+                         bg=parent.cget("bg"), **kw)
+        self._bg      = bg
+        self._fg      = fg
+        self._border  = border or bg
+        self._enabled = True
+        self._command = command
+        pts = _pill_pts(width, height, radius)
+        self._rect = self.create_polygon(pts, smooth=1,
+                                         fill=bg, outline=bg, width=0)
+        self._lbl  = self.create_text(width // 2, height // 2, text=text,
+                                       fill=fg, font=("Segoe UI", 10, "bold"))
+        self.config(cursor="hand2")
+        self.bind("<Button-1>", self._on_click)
+        self.bind("<Enter>",    self._on_enter)
+        self.bind("<Leave>",    self._on_leave)
+
+    def _on_click(self, _e=None):
+        if self._enabled:
+            self._command()
+
+    def _on_enter(self, _e=None):
+        if self._enabled:
+            # If accent-filled, darken; otherwise show slight highlight
+            self.itemconfig(self._rect, fill="#00c060" if self._bg == T["accent"] else T["bg3"])
+
+    def _on_leave(self, _e=None):
+        if self._enabled:
+            self.itemconfig(self._rect, fill=self._bg)
+
+    def set_state(self, state: str):
+        """Enable or disable the button ('normal' / 'disabled')."""
+        self._enabled = (state == "normal")
+        if self._enabled:
+            self.itemconfig(self._rect, fill=self._bg, outline=self._bg)
+            self.itemconfig(self._lbl,  fill=self._fg)
+            self.config(cursor="hand2")
+        else:
+            self.itemconfig(self._rect, fill=T["bg3"], outline=T["bg3"])
+            self.itemconfig(self._lbl,  fill=T["fg2"])
+            self.config(cursor="")
+
+    def set_active(self, active: bool):
+        """Highlight the button as the active tab (accent text only, no outline)."""
+        if active:
+            self.itemconfig(self._lbl, fill=T["accent"])
+        else:
+            self.itemconfig(self._rect, outline=self._border)
+            self.itemconfig(self._lbl,  fill=self._fg)
+
+
+class _CustomNotebook(tk.Frame):
+    """
+    Borderless drop-in replacement for ttk.Notebook.
+    Uses _RoundedButton tab buttons; content frames are shown/hidden via pack.
+    Public API: add(frame, text)  — same signature as ttk.Notebook.add.
+    pack() / pack_forget() are inherited from tk.Frame.
+    """
+
+    def __init__(self, parent, **kw):
+        bg = kw.pop("bg", T["bg"])
+        super().__init__(parent, bg=bg, **kw)
+        self._bg = bg
+        self._tabs: list = []          # (label, frame, _RoundedButton)
+        self._active_frame = None
+
+        # Row of tab buttons
+        self._tab_bar = tk.Frame(self, bg=bg)
+        self._tab_bar.pack(side="top", fill="x", padx=_s(6), pady=(_s(4), _s(2)))
+
+        # Thin separator between tab bar and content area
+        self._sep = tk.Frame(self, bg=T["border"], height=1)
+        self._sep.pack(side="top", fill="x")
+
+    def add(self, frame: tk.Frame, text: str):
+        """Register a content frame as a new tab."""
+        label = text.strip()
+        w = max(_s(55), len(label) * _s(7) + _s(16))
+        btn = _RoundedButton(
+            self._tab_bar, label,
+            lambda l=label: self._show_tab(l),
+            width=w, height=_s(26), radius=_s(6),
+            bg=T["bg3"], fg=T["fg2"], border=T["bg3"],
+        )
+        btn.pack(side="left", padx=(_s(2), 0), pady=_s(2))
+        self._tabs.append((label, frame, btn))
+        # Show the very first tab immediately
+        if len(self._tabs) == 1:
+            frame.pack(fill="both", expand=True)
+            btn.set_active(True)
+            self._active_frame = frame
+
+    def _show_tab(self, label: str):
+        """Switch the visible content frame to the one with the given label."""
+        for lbl, frame, btn in self._tabs:
+            if lbl == label:
+                if self._active_frame is not None and self._active_frame is not frame:
+                    self._active_frame.pack_forget()
+                frame.pack(fill="both", expand=True)
+                btn.set_active(True)
+                self._active_frame = frame
+            else:
+                btn.set_active(False)
+
+
+class _ScoreBar(tk.Frame):
+    """
+    Animated horizontal score bar (0–100) with a rounded pill outline.
+    Matches the top progress-bar colour (green fill, border outline).
+    Call animate_to(value) to animate from 0 to that value.
+    Call reset() to blank it back to zero.
+    """
+    BAR_W = 200   # canvas width  (px)
+    BAR_H = 16    # canvas height (px)
+    PAD   = 2     # gap between canvas edge and the pill track
+
+    def __init__(self, parent, **kw):
+        bg = kw.pop("bg", T["bg2"])
+        super().__init__(parent, bg=bg, **kw)
+        self._bg       = bg
+        self._current  = 0.0
+        self._target   = 0.0
+        self._after_id = None
+        # Scale canvas dimensions to match the display DPI
+        self._bar_w = _s(self.BAR_W)
+        self._bar_h = _s(self.BAR_H)
+        self._pad   = _s(self.PAD)
+
+        self._cv = tk.Canvas(self, width=self._bar_w, height=self._bar_h,
+                             bg=bg, highlightthickness=0, bd=0)
+        self._cv.pack(side="left")
+
+        self._lbl = tk.Label(self, text="—", bg=bg, fg=T["accent"],
+                             font=("Segoe UI", 10, "bold"),
+                             width=4, anchor="w")
+        self._lbl.pack(side="left", padx=(_s(10), 0))
+
+        self._draw_track()
+
+    def _draw_track(self):
+        W, H, P = self._bar_w, self._bar_h, self._pad
+        inner_w = W - 2 * P
+        inner_h = H - 2 * P
+        r = inner_h // 2
+        pts = [v + P for v in _pill_pts(inner_w, inner_h, r=r)]
+        self._cv.create_polygon(pts, smooth=1,
+                                fill="#0d0d0d", outline="#111111",
+                                width=1, tags="track")
+
+    def _draw_fill(self, pct: float):
+        self._cv.delete("fill")
+        if pct <= 0:
+            return
+        W, H, P = self._bar_w, self._bar_h, self._pad
+        inner_w = W - 2 * P
+        inner_h = H - 2 * P
+        r = inner_h // 2                        # = 6
+        fill_px = max(inner_h, int(inner_w * pct / 100.0))
+        fill_px = min(fill_px, inner_w)
+        color   = T["accent"]
+        x0, y0  = P, P
+
+        # Left circle (left rounded cap)
+        self._cv.create_oval(x0, y0, x0 + inner_h, y0 + inner_h,
+                             fill=color, outline="", tags="fill")
+        # Middle rectangle
+        if fill_px > inner_h:
+            self._cv.create_rectangle(x0 + r, y0,
+                                      x0 + fill_px - r, y0 + inner_h,
+                                      fill=color, outline="", tags="fill")
+        # Right circle (right rounded cap)
+        if fill_px >= inner_h:
+            self._cv.create_oval(x0 + fill_px - inner_h, y0,
+                                 x0 + fill_px, y0 + inner_h,
+                                 fill=color, outline="", tags="fill")
+
+    def reset(self):
+        if self._after_id:
+            self.after_cancel(self._after_id)
+            self._after_id = None
+        self._current = 0.0
+        self._target  = 0.0
+        self._draw_fill(0)
+        self._lbl.config(text="—")
+
+    def animate_to(self, target: float):
+        """Animate the bar filling from 0 to target (0–100). Ease-out curve."""
+        if self._after_id:
+            self.after_cancel(self._after_id)
+            self._after_id = None
+        self._current = 0.0
+        self._target  = max(0.0, min(100.0, float(target)))
+        self._lbl.config(text=f"{round(self._target)}%")
+        self._tick()
+
+    def _tick(self):
+        if not self.winfo_exists():
+            return
+        remaining = self._target - self._current
+        if abs(remaining) < 0.4:
+            self._current = self._target
+            self._draw_fill(self._current)
+            return
+        # Ease-out: step = remaining × 0.15, minimum 1.0 per frame
+        self._current += max(1.0, remaining * 0.15)
+        self._current  = min(self._current, self._target)
+        self._draw_fill(self._current)
+        self._after_id = self.after(16, self._tick)   # ~60 fps
+
+
+class _RoundedEntry(tk.Frame):
+    """Entry widget wrapped in a rounded-border canvas frame."""
+    def __init__(self, parent, textvariable, width_px=420, height_px=46,
+                 font=("Segoe UI", 14), radius=10, icon="⌕", **kw):
+        super().__init__(parent, bg=parent.cget("bg"), bd=0, highlightthickness=0)
+        c = tk.Canvas(self, width=width_px, height=height_px,
+                      highlightthickness=0, bd=0, bg=parent.cget("bg"))
+        c.pack()
+        pts = _pill_pts(width_px, height_px, radius)
+        c.create_polygon(pts, smooth=1, fill=T["accent"],
+                         outline=T["accent"], width=1)
+        inner = tk.Frame(c, bg=T["accent"], bd=0, highlightthickness=0)
+        c.create_window(width_px // 2, height_px // 2, window=inner,
+                        width=width_px - 4, height=height_px - 4)
+        if icon:
+            tk.Label(inner, text=icon, bg=T["accent"], fg="#000000",
+                     font=("Segoe UI", 15), padx=_s(12)).pack(side="left")
+        self.entry = tk.Entry(inner, textvariable=textvariable,
+                              bg=T["accent"], fg="#000000", insertbackground="#000000",
+                              font=font, relief="flat", bd=0,
+                              highlightthickness=0, **kw)
+        self.entry.pack(side="left", fill="x", expand=True, ipady=0, padx=(0, _s(12)))
+
+
+# ---------------------------------------------------------------------------
+# Search Tab View
+# ---------------------------------------------------------------------------
+
+class _SearchTabView(tk.Frame):
+    """
+    Google-style stock search view embedded as a tab in the main app.
+    Hero section (centered search bar) transitions to a detail panel
+    below once a result is found.
+    """
+
+    _SCORE_FIELDS  = ScreenerApp._SCORE_FIELDS
+    _VAL_FIELDS    = ScreenerApp._VAL_FIELDS
+    _GROWTH_FIELDS = ScreenerApp._GROWTH_FIELDS
+    _MOM_FIELDS    = ScreenerApp._MOM_FIELDS
+    _QUAL_FIELDS   = ScreenerApp._QUAL_FIELDS
+    _ANLST_FIELDS  = ScreenerApp._ANLST_FIELDS
+
+    def __init__(self, parent, df=None, df_raw=None, get_weights=None):
+        super().__init__(parent, bg=T["bg"])
+        self._df             = df
+        self._df_raw         = df_raw
+        self._get_weights    = get_weights or (lambda: None)
+        self._last_row_dict  = None   # last displayed row (raw, pre-scored fields preserved)
+        self._last_row_live  = False  # True = live fetch, False = from df
+        self._detail_labels: dict = {}
+        self._score_bars: dict    = {}
+        self._chart_ticker   = None
+        self._chart_canvas   = None
+        self._info_popup     = None
+        self._results_shown  = False
+
+        self._build_hero()
+        self._build_results()
+
+    def update_df(self, df, df_raw=None):
+        self._df     = df
+        self._df_raw = df_raw
+
+    def refresh_current_result(self):
+        """Re-score and re-display the current result when the strategy changes."""
+        if self._last_row_dict is None or not self._results_shown:
+            return
+        if not self._last_row_live and self._df is not None:
+            # For df-sourced results, look up the freshly re-scored row
+            ticker = self._last_row_dict.get("ticker", "")
+            mask = self._df["ticker"].str.upper() == ticker.upper()
+            if mask.any():
+                import pandas as pd
+                fresh = self._df[mask].iloc[0]
+                self._last_row_dict = fresh.to_dict()
+                self.after(0, lambda: self._populate(
+                    self._last_row_dict,
+                    f"Found in screener data: {ticker}"))
+                return
+        # For live-fetched results, re-score with new weights
+        try:
+            import pandas as pd
+            row = dict(self._last_row_dict)
+            _weights = self._get_weights()
+            scored = score_stocks(pd.DataFrame([row]), weights=_weights)
+            if not scored.empty:
+                s = scored.iloc[0]
+                for col in ("composite_score", "score_value", "score_growth",
+                            "score_momentum", "score_quality", "score_profitability",
+                            "score_sentiment", "score_analyst", "score_risk"):
+                    if col in s:
+                        row[col] = s[col]
+            self._last_row_dict = row
+            self.after(0, lambda r=row: self._populate(
+                r, f"Live data: {r['ticker']}"))
+        except Exception:
+            pass
+
+    # ── Hero (Google-style centered search) ───────────────────────────── #
+
+    def _build_hero(self):
+        self._hero_outer = tk.Frame(self, bg=T["bg"])
+        self._hero_outer.pack(fill="both", expand=True)
+
+        hero = tk.Frame(self._hero_outer, bg=T["bg"])
+        hero.place(relx=0.5, rely=0.42, anchor="center")
+
+        # App name
+        tk.Label(hero, text=_APP_NAME.upper(), bg=T["bg"], fg=T["accent"],
+                 font=("Segoe UI", 24, "bold")).pack(pady=(0, 28))
+
+        # Rounded search bar
+        self._search_var = tk.StringVar()
+        re_widget = _RoundedEntry(hero, textvariable=self._search_var,
+                                  width_px=_s(440), height_px=_s(48), radius=_s(12))
+        re_widget.pack(pady=(0, _s(4)))
+        re_widget.entry.bind("<Return>", lambda _e: self._do_search())
+        re_widget.entry.focus_set()
+
+        # Rounded search button
+        btn_row = tk.Frame(hero, bg=T["bg"])
+        btn_row.pack(pady=_s(14))
+        _RoundedButton(btn_row, "Search Stock", self._do_search,
+                       width=_s(140), height=_s(38), radius=_s(10)
+                       ).pack(side="left", padx=_s(6))
+
+        # Status label
+        self._search_status = tk.StringVar()
+        tk.Label(hero, textvariable=self._search_status,
+                 bg=T["bg"], fg=T["fg2"], font=T["font_small"]).pack(pady=(4, 0))
+
+    # ── Results panel (hidden until search succeeds) ──────────────────── #
+
+    def _build_results(self):
+        self._results_frame = tk.Frame(self, bg=T["bg"],
+                                       highlightthickness=0)
+
+        # Header row: title + Back button
+        hdr = tk.Frame(self._results_frame, bg=T["bg"])
+        hdr.pack(fill="x", side="top")
+
+        self._detail_title = tk.Label(
+            hdr, text="", bg=T["bg"], fg=T["accent"], font=T["font_head"],
+            anchor="w", pady=12, padx=16)
+        self._detail_title.pack(side="left", fill="x", expand=True)
+
+        back_wrap = tk.Frame(hdr, bg=T["bg"])
+        back_wrap.pack(side="right", padx=_s(12), pady=_s(6))
+        _RoundedButton(back_wrap, "← Back", self._go_back,
+                       width=_s(90), height=_s(32), radius=_s(8)).pack()
+
+        tk.Frame(self._results_frame, bg=T["border"], height=1).pack(fill="x")
+
+        self._notebook = _CustomNotebook(self._results_frame)
+        self._notebook.pack(fill="both", expand=True)
+
+        # Scores tab — animated bar widgets
+        scores_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(scores_tab, text="  Scores  ")
+        self._build_scores_tab_content(scores_tab)
+
+        for title, fields in [
+            ("Valuation",        self._VAL_FIELDS),
+            ("Growth",           self._GROWTH_FIELDS),
+            ("Momentum",         self._MOM_FIELDS),
+            ("Quality & Profit", self._QUAL_FIELDS),
+        ]:
+            tab = tk.Frame(self._notebook, bg=T["bg"])
+            self._notebook.add(tab, text=f"  {title}  ")
+            self._detail_labels.update(self._build_tab_content(tab, fields))
+
+        analyst_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(analyst_tab, text="  Analyst  ")
+        self._build_analyst_tab(analyst_tab)
+
+        self._chart_ticker = None
+        chart_tab = tk.Frame(self._notebook, bg=T["bg"])
+        self._notebook.add(chart_tab, text="  Chart  ")
+        self._chart_period = tk.StringVar(value="6mo")
+        self._chart_parent_frame = chart_tab
+        self._build_chart_tab_simple(chart_tab)
+
+    def _show_results(self):
+        if not self._results_shown:
+            self._hero_outer.pack_forget()
+            self._results_frame.pack(fill="both", expand=True, padx=10, pady=(6, 10))
+            self._results_shown = True
+
+    def _go_back(self):
+        """Return to the centered hero search view."""
+        self._results_frame.pack_forget()
+        self._hero_outer.pack_forget()
+        self._hero_outer.pack(fill="both", expand=True)
+        self._results_shown = False
+        self._search_status.set("")
+        self._search_var.set("")
+
+    def _build_chart_tab_simple(self, parent):
+        ctrl = tk.Frame(parent, bg=T["bg"])
+        ctrl.pack(fill="x", side="top")
+        tk.Frame(ctrl, bg=T["bg"], width=_s(12)).pack(side="left")
+        for val, lbl in [("1mo","1M"),("3mo","3M"),("6mo","6M"),
+                          ("1y","1Y"),("2y","2Y"),("5y","5Y")]:
+            b = tk.Radiobutton(
+                ctrl, text=lbl, variable=self._chart_period, value=val,
+                bg=T["bg"], fg=T["fg2"], selectcolor=T["accent"],
+                activebackground=T["bg"], activeforeground=T["accent"],
+                font=("Segoe UI", 9, "bold"), indicatoron=False,
+                relief="flat", overrelief="flat", padx=_s(10), pady=_s(5), bd=0,
+                cursor="hand2", command=self._refresh_chart,
+            )
+            b.pack(side="left", padx=1, pady=(_s(4), 0))
+        tk.Frame(ctrl, bg=T["border"], height=1).pack(fill="x", side="bottom")
+        self._chart_canvas_placeholder = tk.Label(
+            parent, text="Search for a stock to view its price chart.",
+            bg=T["bg"], fg=T["fg2"], font=T["font_small"])
+        self._chart_canvas_placeholder.pack(expand=True)
+
+    def _refresh_chart(self):
+        if self._chart_ticker:
+            threading.Thread(
+                target=self._fetch_and_render_chart,
+                args=(self._chart_ticker, self._chart_period.get(),
+                      "_chart_canvas", self._chart_parent_frame),
+                daemon=True,
+            ).start()
+
+    # ── Search logic ──────────────────────────────────────────────────── #
+
+    def _do_search(self):
+        query = self._search_var.get().strip().lstrip("$")
+        if not query:
+            return
+        self._search_status.set("Searching…")
+        self.update_idletasks()
+        threading.Thread(target=self._search_worker, args=(query,), daemon=True).start()
+
+    def _search_worker(self, query: str):
+        try:
+            row = self._find_in_df(query)
+            if row is not None:
+                import pandas as pd
+                if isinstance(row, pd.Series):
+                    _row_d = row.to_dict()
+                else:
+                    _row_d = dict(row)
+                self._last_row_dict = _row_d
+                self._last_row_live = False
+                def _safe_populate_df():
+                    try:
+                        self._populate(_row_d, f"Found in screener data: {_row_d['ticker']}")
+                    except Exception as exc:
+                        self._search_status.set(f"Display error: {exc}")
+                self.after(0, _safe_populate_df)
+                return
+
+            # Run _fetch_live in a sub-thread so we can impose a timeout
+            self.after(0, self._search_status.set, "Fetching data…")
+            fetch_result = [None]
+
+            def _do_fetch():
+                fetch_result[0] = _StockLookupWindow._fetch_live(self, query)
+
+            fetch_thread = threading.Thread(target=_do_fetch, daemon=True)
+            fetch_thread.start()
+            fetch_thread.join(timeout=20)
+
+            if fetch_thread.is_alive():
+                self.after(0, self._search_status.set,
+                           "Search timed out. Check your connection and try again.")
+                return
+
+            live_row = fetch_result[0]
+            if live_row is None:
+                self.after(0, self._search_status.set,
+                           f"No results for '{query}'. Try the exact ticker symbol.")
+                return
+
+            # Score the live row using the current strategy's weights
+            try:
+                import pandas as pd
+                _weights = self._get_weights()
+                scored = score_stocks(pd.DataFrame([live_row]), weights=_weights)
+                if not scored.empty:
+                    s = scored.iloc[0]
+                    for col in ("composite_score", "score_value", "score_growth",
+                                "score_momentum", "score_quality", "score_profitability",
+                                "score_sentiment", "score_analyst", "score_risk"):
+                        if col in s:
+                            live_row[col] = s[col]
+            except Exception:
+                pass
+
+            self._last_row_dict = dict(live_row)
+            self._last_row_live = True
+
+            def _safe_populate_live():
+                try:
+                    self._populate(live_row, f"Live data: {live_row['ticker']}")
+                except Exception as exc:
+                    self._search_status.set(f"Display error: {exc}")
+            self.after(0, _safe_populate_live)
+
+        except Exception as exc:
+            self.after(0, self._search_status.set, f"Search error: {exc}")
+
+    def _find_in_df(self, query: str):
+        if self._df is None or self._df.empty:
+            return None
+        q = query.upper().strip().lstrip("$")
+        mask = self._df["ticker"].str.upper() == q
+        if mask.any():
+            return self._df[mask].iloc[0]
+        if "name" in self._df.columns:
+            mask2 = self._df["name"].str.upper().str.contains(q, regex=False, na=False)
+            if mask2.any():
+                return self._df[mask2].iloc[0]
+        return None
+
+    def _populate(self, row, status_msg: str):
+        import pandas as pd
+        if isinstance(row, pd.Series):
+            row = row.to_dict()
+        self._show_results()
+        # Delegate to _StockLookupWindow._populate which sets _search_status
+        # and populates all detail labels, score bars, commentary, and chart.
+        _StockLookupWindow._populate(self, row, status_msg)
+
+    # Delegate shared rendering to ScreenerApp / _StockLookupWindow
+    _build_tab_content          = ScreenerApp._build_tab_content
+    _build_scores_tab_content   = ScreenerApp._build_scores_tab_content
+    _update_score_bars          = ScreenerApp._update_score_bars
+    _build_analyst_tab          = ScreenerApp._build_analyst_tab
+    _update_commentary          = ScreenerApp._update_commentary
+    _show_info_popup            = ScreenerApp._show_info_popup
+    _fetch_and_render_chart     = ScreenerApp._fetch_and_render_chart
+    _render_chart               = ScreenerApp._render_chart
+    _set_chart_placeholder_text = ScreenerApp._set_chart_placeholder_text
+    _fetch_live                 = _StockLookupWindow._fetch_live
+
+    def _get_tooltip_text(self, label: str) -> str:
+        return _METRIC_TOOLTIPS.get(label, "")
+
+
+# ---------------------------------------------------------------------------
+# Tracking Tab — SEC EDGAR Form 4 Insider Transactions
+# ---------------------------------------------------------------------------
+
+class _TrackingTabView(tk.Frame):
+    """
+    Finviz-style insider trading table backed by SEC EDGAR Form 4 filings.
+    Fetches data in a background thread; clicking a row opens the SEC filing.
+    """
+
+    _COLS = [
+        ("Date",    72,  "center"),
+        ("Ticker",  65,  "center"),
+        ("Company", 175, "w"),
+        ("Insider", 155, "w"),
+        ("Title",   125, "w"),
+        ("Type",     90, "center"),
+        ("Shares",   90, "e"),
+        ("Price",    70, "e"),
+        ("Value",    90, "e"),
+        ("After",    95, "e"),
+    ]
+
+    _PERIODS = [("Today", 1), ("3D", 3), ("1W", 7), ("2W", 14)]
+    _TYPES   = [("All", "all"), ("Buys", "buy"), ("Sales", "sale")]
+
+    def __init__(self, parent):
+        super().__init__(parent, bg=T["bg"])
+        self._all_trades:   list[dict] = []
+        self._iid_to_url:   dict[str, str] = {}
+        self._loading     = False
+        self._has_loaded  = False
+        self._days_back   = 3
+        self._type_filter = "all"
+        self._sort_asc_map: dict[str, bool] = {}
+        self._status_var  = tk.StringVar(
+            value="Click  ↻ Refresh  to load insider trading data.")
+        self._period_btns: dict = {}
+        self._type_btns:   dict = {}
+
+        self._build_controls()
+        self._build_table()
+
+    # ── Controls ─────────────────────────────────────────────────────────── #
+
+    def _build_controls(self):
+        outer = tk.Frame(self, bg=T["bg"])
+        outer.pack(fill="x", padx=_s(10), pady=(_s(8), 0))
+
+        tk.Label(outer, text="Insider Transactions", bg=T["bg"], fg=T["accent"],
+                 font=("Segoe UI", 12, "bold")).pack(side="left",
+                                                      padx=(0, _s(16)))
+
+        def _vsep():
+            tk.Frame(outer, bg=T["border"], width=1,
+                     height=_s(20)).pack(side="left", padx=_s(10), fill="y")
+
+        # Period selector
+        tk.Label(outer, text="Period", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+        for lbl, days in self._PERIODS:
+            w = max(_s(38), len(lbl) * _s(7) + _s(10))
+            b = _RoundedButton(outer, lbl, lambda d=days: self._set_period(d),
+                               width=w, height=_s(26), radius=_s(6),
+                               bg=T["bg3"], fg=T["fg2"], border=T["bg3"])
+            b.pack(side="left", padx=(_s(4), 0))
+            self._period_btns[days] = b
+        self._activate_btn(self._period_btns, self._days_back)
+
+        _vsep()
+
+        # Type filter
+        tk.Label(outer, text="Type", bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left")
+        for lbl, val in self._TYPES:
+            w = max(_s(38), len(lbl) * _s(7) + _s(10))
+            b = _RoundedButton(outer, lbl, lambda v=val: self._set_type(v),
+                               width=w, height=_s(26), radius=_s(6),
+                               bg=T["bg3"], fg=T["fg2"], border=T["bg3"])
+            b.pack(side="left", padx=(_s(4), 0))
+            self._type_btns[val] = b
+        self._activate_btn(self._type_btns, self._type_filter)
+
+        _vsep()
+
+        self._refresh_btn = _RoundedButton(
+            outer, "\u21bb  Refresh", self._refresh,
+            width=_s(100), height=_s(26), radius=_s(6))
+        self._refresh_btn.pack(side="left")
+
+        tk.Label(outer, textvariable=self._status_var, bg=T["bg"], fg=T["fg2"],
+                 font=T["font_small"]).pack(side="left", padx=(_s(14), 0))
+
+        tk.Frame(self, bg=T["border"], height=1).pack(
+            fill="x", padx=_s(10), pady=(_s(8), 0))
+
+    # ── Table ─────────────────────────────────────────────────────────────── #
+
+    def _build_table(self):
+        frame = tk.Frame(self, bg=T["bg"])
+        frame.pack(fill="both", expand=True, padx=_s(10), pady=(_s(6), _s(8)))
+
+        cols = [c[0] for c in self._COLS]
+        self._tree = ttk.Treeview(frame, columns=cols, show="headings",
+                                  selectmode="browse")
+
+        for col, w, anchor in self._COLS:
+            self._tree.heading(col, text=col,
+                               command=lambda c=col: self._sort_column(c))
+            self._tree.column(col, width=_s(w), anchor=anchor,
+                              stretch=(col == "Company"))
+
+        # Alternating backgrounds
+        self._tree.tag_configure("odd",  background=T["row_odd"])
+        self._tree.tag_configure("even", background=T["row_even"])
+        # Transaction-type foreground colours
+        self._tree.tag_configure("c_buy",   foreground=T["accent"])
+        self._tree.tag_configure("c_sale",  foreground=T["red"])
+        self._tree.tag_configure("c_award", foreground=T["yellow"])
+        self._tree.tag_configure("c_other", foreground=T["fg2"])
+
+        vsb = ttk.Scrollbar(frame, orient="vertical",   command=self._tree.yview)
+        hsb = ttk.Scrollbar(frame, orient="horizontal", command=self._tree.xview)
+        self._tree.configure(yscrollcommand=vsb.set, xscrollcommand=hsb.set)
+
+        self._tree.grid(row=0, column=0, sticky="nsew")
+        vsb.grid(row=0, column=1, sticky="ns")
+        hsb.grid(row=1, column=0, sticky="ew")
+        frame.grid_rowconfigure(0, weight=1)
+        frame.grid_columnconfigure(0, weight=1)
+
+        self._tree.bind("<<TreeviewSelect>>", self._on_row_select)
+
+    # ── Button group ──────────────────────────────────────────────────────── #
+
+    @staticmethod
+    def _activate_btn(btn_dict: dict, active_key):
+        for key, btn in btn_dict.items():
+            is_active = (key == active_key)
+            bg = T["accent"] if is_active else T["bg3"]
+            fg = "#000000"   if is_active else T["fg2"]
+            btn._bg = bg; btn._fg = fg; btn._border = bg
+            btn.itemconfig(btn._rect, fill=bg, outline=bg)
+            btn.itemconfig(btn._lbl,  fill=fg)
+
+    def _set_period(self, days: int):
+        self._days_back = days
+        self._activate_btn(self._period_btns, days)
+        self._refresh()
+
+    def _set_type(self, val: str):
+        self._type_filter = val
+        self._activate_btn(self._type_btns, val)
+        self._apply_filter()
+
+    # ── Data fetch ────────────────────────────────────────────────────────── #
+
+    def on_show(self):
+        """Called each time the tab becomes visible; auto-fetches on first show."""
+        if not self._has_loaded:
+            self._refresh()
+
+    def _refresh(self):
+        if self._loading:
+            return
+        self._loading = True
+        self._refresh_btn.set_state("disabled")
+        self._status_var.set("Fetching from SEC EDGAR...")
+        days = self._days_back
+
+        def _progress(done, total):
+            self.after(0, lambda: self._status_var.set(
+                f"Loading... ({done}/{total} filings)"))
+
+        def _worker():
+            try:
+                trades = fetch_insider_trades(
+                    days_back=days, max_results=60, progress_cb=_progress)
+            except Exception:
+                trades = []
+            self.after(0, lambda t=trades: self._on_fetched(t))
+
+        threading.Thread(target=_worker, daemon=True).start()
+
+    def _on_fetched(self, trades: list):
+        self._loading    = False
+        self._has_loaded = True
+        self._all_trades = trades
+        self._refresh_btn.set_state("normal")
+        self._apply_filter()
+        n = len(trades)
+        if n:
+            self._status_var.set(
+                f"{n} transaction{'s' if n != 1 else ''} loaded.")
+        else:
+            self._status_var.set("No transactions found for this period.")
+
+    # ── Filter & populate ─────────────────────────────────────────────────── #
+
+    def _apply_filter(self):
+        trades = self._all_trades or []
+        f = self._type_filter
+        if f == "buy":
+            trades = [t for t in trades if t.get("transaction_code") == "P"]
+        elif f == "sale":
+            trades = [t for t in trades if t.get("transaction_code") == "S"]
+        self._populate_table(trades)
+
+    def _populate_table(self, trades: list):
+        self._tree.delete(*self._tree.get_children())
+        self._iid_to_url.clear()
+
+        for i, tx in enumerate(trades):
+            bg_tag    = "odd" if i % 2 else "even"
+            tc        = tx.get("transaction_code", "")
+            color_tag = {"P": "c_buy", "S": "c_sale",
+                         "A": "c_award"}.get(tc, "c_other")
+
+            # Format date "YYYY-MM-DD" → "Mon DD"
+            date_str = tx.get("tx_date") or tx.get("filed_date") or ""
+            try:
+                import calendar as _cal
+                y, m, d = date_str[:10].split("-")
+                date_str = f"{_cal.month_abbr[int(m)]} {int(d)}"
+            except Exception:
+                pass
+
+            iid = str(i)
+            self._iid_to_url[iid] = tx.get("url", "")
+
+            self._tree.insert("", "end", iid=iid,
+                              tags=(bg_tag, color_tag),
+                              values=(
+                                  date_str,
+                                  tx.get("ticker", "—"),
+                                  (tx.get("company") or "")[:26],
+                                  (tx.get("insider") or "")[:22],
+                                  (tx.get("title")   or "")[:18],
+                                  tx.get("transaction_type", "—"),
+                                  _fmt_shares(tx.get("shares")),
+                                  _price(tx.get("price")) if tx.get("price") else "—",
+                                  _fmt_value(tx.get("value")),
+                                  _fmt_shares(tx.get("owned_after")),
+                              ))
+
+    # ── Sorting ───────────────────────────────────────────────────────────── #
+
+    def _sort_column(self, col: str):
+        data = [(self._tree.set(iid, col), iid)
+                for iid in self._tree.get_children("")]
+
+        def _key(pair):
+            s = pair[0].replace(",", "").replace("$", "").replace("—", "").strip()
+            for sfx, mult in [("B", 1e9), ("M", 1e6), ("K", 1e3)]:
+                if s.endswith(sfx):
+                    try: return (0, float(s[:-1]) * mult)
+                    except: pass
+            try: return (0, float(s))
+            except: return (1, s.lower())
+
+        asc = self._sort_asc_map.get(col, False)
+        data.sort(key=_key, reverse=not asc)
+        self._sort_asc_map[col] = not asc
+
+        for idx, (_, iid) in enumerate(data):
+            self._tree.move(iid, "", idx)
+            tags = [t for t in self._tree.item(iid, "tags")
+                    if t not in ("odd", "even")]
+            tags.append("odd" if idx % 2 else "even")
+            self._tree.item(iid, tags=tags)
+
+    # ── Row click ─────────────────────────────────────────────────────────── #
+
+    def _on_row_select(self, _event=None):
+        sel = self._tree.selection()
+        if not sel:
+            return
+        url = self._iid_to_url.get(sel[0], "")
+        if url:
+            webbrowser.open(url)
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def main():
+    app = ScreenerApp()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/dist/stock_screener.py b/dist/stock_screener.py
new file mode 100644
index 0000000..020a4dd
--- /dev/null
+++ b/dist/stock_screener.py
@@ -0,0 +1,2086 @@
+"""
+Stock Evaluation Screener
+=========================
+Evaluates every common stock listed on NYSE, NASDAQ, and AMEX (~6 500+ tickers)
+using a multi-factor composite scoring formula designed to act as a quantitative
+analyst.  This covers all major US indices: S&P 500/400/600, Russell 1000/2000/3000,
+DJIA, NYSE Composite, NASDAQ Composite, and every sector/thematic index derived
+from US-listed equities.
+
+FORMULA (Composite Score):
+  Score = 0.18*Value + 0.18*Growth + 0.14*Momentum + 0.11*Quality
+        + 0.08*Profitability + 0.13*Sentiment + 0.10*Analyst + 0.08*Risk
+
+  Each component is scored 0–100 based on absolute benchmarks for that metric.
+  Scores are INDEPENDENT — each stock is evaluated on its own merits, not
+  relative to other stocks in the dataset.
+
+  Value         — how attractively priced (P/E, P/B, EV/EBITDA vs benchmarks)
+  Growth        — revenue, earnings, and EPS trajectory
+  Momentum      — price return across 1M/3M/6M/12M windows
+  Quality       — financial strength (ROE, ROA, debt, liquidity)
+  Profitability — margins and free cash flow yield
+  Sentiment     — recent news tone via VADER NLP
+  Analyst       — consensus rating and upside to price target
+  Risk          — short interest, volatility, and beta stability
+"""
+
+import argparse
+import html
+import random
+import re
+import sys
+import time
+import warnings
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime, timedelta, timezone
+
+import numpy as np
+import pandas as pd
+import requests
+import yfinance as yf
+
+warnings.filterwarnings("ignore")
+
+# ---------------------------------------------------------------------------
+# VADER sentiment — optional but strongly recommended
+# pip install vaderSentiment
+# ---------------------------------------------------------------------------
+
+try:
+    from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+    _VADER = SentimentIntensityAnalyzer()
+except ImportError:
+    _VADER = None
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+WEIGHTS = {
+    "value":         0.18,
+    "growth":        0.18,
+    "momentum":      0.14,
+    "quality":       0.11,
+    "profitability": 0.08,
+    "sentiment":     0.13,
+    "analyst":       0.10,
+    "risk":          0.08,
+}
+
+# Human-readable investment strategy presets.
+# Each preset is a complete weight dict that must sum to 1.0.
+STRATEGY_PRESETS = {
+    "Balanced (Default)": {
+        "value": 0.18, "growth": 0.18, "momentum": 0.14, "quality": 0.11,
+        "profitability": 0.08, "sentiment": 0.13, "analyst": 0.10, "risk": 0.08,
+    },
+    "High Growth Companies": {
+        "value": 0.08, "growth": 0.28, "momentum": 0.25, "quality": 0.08,
+        "profitability": 0.08, "sentiment": 0.12, "analyst": 0.07, "risk": 0.04,
+    },
+    "Conservative": {
+        "value": 0.20, "growth": 0.12, "momentum": 0.06, "quality": 0.25,
+        "profitability": 0.18, "sentiment": 0.06, "analyst": 0.08, "risk": 0.05,
+    },
+    "Recent Uptrends": {
+        "value": 0.05, "growth": 0.12, "momentum": 0.40, "quality": 0.05,
+        "profitability": 0.05, "sentiment": 0.18, "analyst": 0.10, "risk": 0.05,
+    },
+    "Buy and Hold Long Term": {
+        "value": 0.30, "growth": 0.22, "momentum": 0.05, "quality": 0.20,
+        "profitability": 0.15, "sentiment": 0.03, "analyst": 0.05, "risk": 0.00,
+    },
+    "Low Risk, High Dividend Yield": {
+        "value": 0.22, "growth": 0.10, "momentum": 0.05, "quality": 0.22,
+        "profitability": 0.28, "sentiment": 0.05, "analyst": 0.05, "risk": 0.03,
+    },
+    "High Risk High Reward": {
+        "value": 0.10, "growth": 0.00, "momentum": 0.00, "quality": 0.15,
+        "profitability": 0.00, "sentiment": 0.05, "analyst": 0.30, "risk": 0.05,
+        "reverse_momentum": 0.35,
+    },
+}
+
+HIST_BATCH  = 100   # tickers per yf.download() batch
+HIST_PAUSE  = 3.0   # seconds between history batches
+INFO_BATCH  = 20    # tickers per info-fetch batch
+INFO_PAUSE  = 4.0   # seconds between info batches
+BATCH_SIZE  = INFO_BATCH
+BATCH_PAUSE = INFO_PAUSE
+
+
+# ---------------------------------------------------------------------------
+# Ticker Fetching
+# ---------------------------------------------------------------------------
+
+# Valid common-stock ticker: 1-5 uppercase letters, optionally followed by
+# a dash and 1-2 letters for share classes (e.g. BRK-A, BRK-B)
+_TICKER_RE = re.compile(r'^[A-Z]{1,5}(-[A-Z]{1,2})?$')
+
+def _clean_ticker(symbol: str) -> str | None:
+    """Normalize a raw symbol and return it if it looks like a common stock."""
+    t = symbol.strip().upper().replace(".", "-")
+    return t if _TICKER_RE.match(t) else None
+
+
+_NASDAQ100_FALLBACK = [
+    "AAPL", "MSFT", "NVDA", "AMZN", "META", "GOOGL", "GOOG", "TSLA", "AVGO", "COST",
+    "NFLX", "TMUS", "ASML", "AMD", "PEP", "LIN", "CSCO", "ADBE", "QCOM", "INTU",
+    "TXN", "AMAT", "AMGN", "CMCSA", "ISRG", "MU", "LRCX", "MRVL", "KLAC", "REGN",
+    "PANW", "CRWD", "SNPS", "CDNS", "ABNB", "ORLY", "MNST", "NXPI", "FTNT", "MAR",
+    "AEP", "PYPL", "MCHP", "PAYX", "ADSK", "CTAS", "IDXX", "ROST", "KDP", "FAST",
+    "ODFL", "DXCM", "VRSK", "CPRT", "BKR", "GEHC", "ON",   "EXC", "LULU", "ZS",
+    "TEAM", "PCAR", "WDAY", "CTSH", "BIIB", "GILD", "CEG", "TTD", "MRNA", "EA",
+    "EBAY", "ILMN", "INTC", "SMCI", "ARM",  "FANG", "WBD", "DLTR", "SIRI", "GFS",
+    "HON",  "MSTR", "DASH", "RBLX", "COIN", "DDOG", "ZM",  "OKTA", "SNOW", "NET",
+    "HUBS", "BILL", "CFLT", "MDB",  "GTLB", "U",    "APP", "PINS", "RIVN", "UBER",
+]
+
+def get_nasdaq100_tickers() -> list[str]:
+    """Live NASDAQ-100 from Wikipedia; falls back to a hardcoded list."""
+    tickers = _fetch_wikipedia_index(
+        "https://en.wikipedia.org/wiki/Nasdaq-100", "NASDAQ 100")
+    if tickers:
+        return tickers
+    print("  [WARN] Using hardcoded NASDAQ-100 fallback list")
+    tickers = list(dict.fromkeys(_NASDAQ100_FALLBACK))
+    print(f"  NASDAQ 100  : {len(tickers):>5} tickers (fallback)")
+    return tickers
+
+
+_NASDAQ_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+    "Accept":     "application/json, text/plain, */*",
+    "Referer":    "https://www.nasdaq.com/",
+}
+
+def _fetch_exchange(exchange: str) -> list[str]:
+    """
+    Pull every listed stock for one exchange from the NASDAQ screener API.
+    Covers NYSE (~2 800 tickers), NASDAQ (~3 500), and AMEX (~300).
+    Together these three exchanges list every component of every major US index:
+    S&P 500/400/600, Russell 1000/2000/3000, DJIA, NYSE Composite, etc.
+    """
+    url = (
+        "https://api.nasdaq.com/api/screener/stocks"
+        f"?tableonly=true&limit=10000&exchange={exchange}&download=true"
+    )
+    try:
+        resp = requests.get(url, headers=_NASDAQ_HEADERS, timeout=30)
+        resp.raise_for_status()
+        rows = resp.json()["data"]["table"]["rows"]
+        tickers = [_clean_ticker(r.get("symbol", "")) for r in rows]
+        tickers = [t for t in tickers if t]
+        print(f"  {exchange:<8}: {len(tickers):>5} tickers")
+        return tickers
+    except Exception as e:
+        print(f"  [WARN] Could not fetch {exchange} tickers: {e}")
+        return []
+
+
+def _fetch_nasdaqtrader_listings(exchange_filter: str | None = None) -> list[str]:
+    """
+    Download the official NASDAQ Trader exchange listing flat files.
+    These are publicly accessible static files updated daily — no API key,
+    no bot detection, no rate limiting.
+
+    exchange_filter: None = all exchanges, or "NASDAQ", "NYSE", "AMEX"
+
+    nasdaqlisted.txt  — every NASDAQ-listed stock
+      cols: Symbol | Name | MarketCat | TestIssue | FinancialStatus | LotSize | ETF | NextShares
+
+    otherlisted.txt   — every NYSE / AMEX / Arca / BATS / IEX listed stock
+      cols: ACTSymbol | Name | Exchange | CQSSymbol | ETF | LotSize | TestIssue | NASDAQSymbol
+      Exchange codes: N=NYSE  A=AMEX/NYSE-American  P=NYSE-Arca  Z=BATS  V=IEX
+    """
+    from io import StringIO
+    base    = "https://www.nasdaqtrader.com/dynamic/SymDir/"
+    tickers = []
+
+    # ── nasdaqlisted.txt ──────────────────────────────────────────────────
+    if exchange_filter in (None, "NASDAQ"):
+        try:
+            resp = requests.get(base + "nasdaqlisted.txt",
+                                headers=_HTTP_HEADERS, timeout=20)
+            resp.raise_for_status()
+            count = 0
+            for line in resp.text.splitlines()[1:]:
+                if line.startswith("File Creation"):
+                    break
+                parts = line.split("|")
+                if len(parts) < 7:
+                    continue
+                test_issue = parts[3].strip()   # col 3 = TestIssue
+                is_etf     = parts[6].strip()   # col 6 = ETF
+                if test_issue == "Y" or is_etf == "Y":
+                    continue
+                t = _clean_ticker(parts[0].strip())
+                if t:
+                    tickers.append(t)
+                    count += 1
+            print(f"  NASDAQ listed  : {count:>5} tickers")
+        except Exception as e:
+            print(f"  [WARN] nasdaqlisted.txt failed: {e}")
+
+    # ── otherlisted.txt ───────────────────────────────────────────────────
+    if exchange_filter in (None, "NYSE", "AMEX"):
+        # Map friendly name → exchange code(s) in the file
+        _code_map = {
+            "NYSE": {"N"},
+            "AMEX": {"A"},
+            None:   {"N", "A", "P", "Z", "V"},
+        }
+        allowed_codes = _code_map.get(exchange_filter, {"N", "A", "P", "Z", "V"})
+        try:
+            resp = requests.get(base + "otherlisted.txt",
+                                headers=_HTTP_HEADERS, timeout=20)
+            resp.raise_for_status()
+            count = 0
+            for line in resp.text.splitlines()[1:]:
+                if line.startswith("File Creation"):
+                    break
+                parts = line.split("|")
+                if len(parts) < 7:
+                    continue
+                exchange   = parts[2].strip()   # col 2 = Exchange code
+                is_etf     = parts[4].strip()   # col 4 = ETF
+                test_issue = parts[6].strip()   # col 6 = TestIssue
+                if test_issue == "Y" or is_etf == "Y":
+                    continue
+                if exchange not in allowed_codes:
+                    continue
+                t = _clean_ticker(parts[0].strip())
+                if t:
+                    tickers.append(t)
+                    count += 1
+            lbl = exchange_filter or "other exchanges"
+            print(f"  {lbl:<15}: {count:>5} tickers")
+        except Exception as e:
+            print(f"  [WARN] otherlisted.txt failed: {e}")
+
+    return tickers
+
+
+def _fetch_otc_tickers() -> list[str]:
+    """
+    Fetch OTC-traded US company tickers from SEC EDGAR's exchange-tagged file.
+    company_tickers_exchange.json tags every SEC-registered company with its
+    exchange (Nasdaq, NYSE, OTC, etc.) — no bot detection, same source we
+    already trust for the fallback ticker list.
+
+    Filters to entries where exchange == "OTC", giving OTCQX / OTCQB /
+    Pink Sheet stocks not covered by the NASDAQ Trader exchange files.
+    """
+    try:
+        resp = requests.get(
+            "https://www.sec.gov/files/company_tickers_exchange.json",
+            headers={"User-Agent": "stockscreener contact@example.com"},
+            timeout=20,
+        )
+        resp.raise_for_status()
+        payload = resp.json()
+        # Format: {"fields": ["cik","name","ticker","exchange"], "data": [[...], ...]}
+        fields = payload.get("fields", [])
+        rows   = payload.get("data", [])
+        try:
+            exch_idx   = fields.index("exchange")
+            ticker_idx = fields.index("ticker")
+        except ValueError:
+            print("  [WARN] SEC EDGAR exchange file format changed — no OTC tickers")
+            return []
+
+        tickers = [
+            _clean_ticker(str(row[ticker_idx]))
+            for row in rows
+            if str(row[exch_idx]).upper() == "OTC"
+        ]
+        tickers = [t for t in tickers if t]
+        print(f"  OTC (SEC EDGAR): {len(tickers):>5} tickers")
+        return tickers
+    except Exception as e:
+        print(f"  [WARN] SEC EDGAR OTC fetch failed: {e}")
+        return []
+
+
+def _fetch_sec_all_tickers() -> list[str]:
+    """
+    Pull every US-listed company ticker from the SEC EDGAR company tickers file.
+    This is a publicly accessible, bot-friendly endpoint (~10 000+ tickers).
+    Used as the fallback when NASDAQ Trader files are unavailable.
+    """
+    try:
+        resp = requests.get(
+            "https://www.sec.gov/files/company_tickers.json",
+            headers={"User-Agent": "stockscreener contact@example.com"},
+            timeout=20,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        tickers = [_clean_ticker(v.get("ticker", "")) for v in data.values()]
+        tickers = [t for t in tickers if t]
+        print(f"  SEC EDGAR   : {len(tickers):>5} tickers")
+        return tickers
+    except Exception as e:
+        print(f"  [WARN] SEC EDGAR ticker fetch failed: {e}")
+        return []
+
+
+_HTTP_HEADERS = {"User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64)"}
+
+
+def _fetch_sp500() -> list[str]:
+    # Primary: Wikipedia — reflects additions/removals as soon as the page updates
+    tickers = _fetch_wikipedia_index(
+        "https://en.wikipedia.org/wiki/List_of_S%26P_500_companies", "S&P 500")
+    if tickers:
+        return tickers
+    # Fallback: community-maintained GitHub CSV
+    try:
+        from io import StringIO
+        url = ("https://raw.githubusercontent.com/datasets/"
+               "s-and-p-500-companies/main/data/constituents.csv")
+        resp = requests.get(url, headers=_HTTP_HEADERS, timeout=20)
+        resp.raise_for_status()
+        tickers = [_clean_ticker(t)
+                   for t in pd.read_csv(StringIO(resp.text))["Symbol"]]
+        tickers = [t for t in tickers if t]
+        print(f"  S&P 500     : {len(tickers):>5} tickers (GitHub fallback)")
+        return tickers
+    except Exception as e:
+        print(f"  [WARN] S&P 500 GitHub fallback failed: {e}")
+        return []
+
+
+def _fetch_wikipedia_index(url: str, label: str, min_count: int = 10) -> list[str]:
+    """
+    Pull index constituents from a Wikipedia list-of-companies page.
+    Strips footnote markers (e.g. 'AAPL[a]') and skips tables that are
+    too small to be the real index table (avoids false positives).
+    """
+    try:
+        from io import StringIO
+        resp = requests.get(url, headers=_HTTP_HEADERS, timeout=20)
+        resp.raise_for_status()
+        tables = pd.read_html(StringIO(resp.text))
+        for df in tables:
+            for col in ("Symbol", "Ticker", "Ticker symbol"):
+                if col in df.columns:
+                    # Strip footnote brackets like [a], [1], [note 1]
+                    cleaned = (df[col].astype(str)
+                               .str.replace(r'\[.*?\]', '', regex=True)
+                               .str.strip())
+                    tickers = [_clean_ticker(t) for t in cleaned]
+                    tickers = [t for t in tickers if t]
+                    if len(tickers) < min_count:
+                        continue   # skip unrelated small tables
+                    print(f"  {label:<12}: {len(tickers):>5} tickers")
+                    return tickers
+    except Exception as e:
+        print(f"  [WARN] {label} failed: {e}")
+    return []
+
+
+# iShares Russell ETF holdings CSVs — publicly downloadable
+_RUSSELL_ETFS = {
+    "Russell 1000": ("239707", "ishares-russell-1000-etf", "IWB"),
+    "Russell 2000": ("239659", "ishares-russell-2000-etf", "IWM"),
+    "Russell 3000": ("239714", "ishares-russell-3000-etf", "IWV"),
+}
+
+def _fetch_russell(label: str) -> list[str]:
+    product_id, slug, etf = _RUSSELL_ETFS[label]
+    url = (
+        f"https://www.ishares.com/us/products/{product_id}/{slug}"
+        f"/1467271812596.ajax?fileType=csv&fileName={etf}_holdings&dataType=fund"
+    )
+    try:
+        from io import StringIO
+        resp = requests.get(url, headers=_HTTP_HEADERS, timeout=40)
+        resp.raise_for_status()
+        lines = resp.text.splitlines()
+        # iShares CSVs have a few metadata lines before the real header
+        header_idx = next(
+            (i for i, ln in enumerate(lines)
+             if ln.startswith("Ticker,") or ",Ticker," in ln or ln.startswith("Name,")),
+            None,
+        )
+        if header_idx is None:
+            raise ValueError("Header row not found in iShares CSV")
+        df = pd.read_csv(StringIO("\n".join(lines[header_idx:])))
+        col = next((c for c in df.columns if c.strip() == "Ticker"), None)
+        if not col:
+            raise ValueError("'Ticker' column missing")
+        tickers = [_clean_ticker(str(t)) for t in df[col]]
+        tickers = [t for t in tickers if t and t.upper() not in ("-", "NAN", "CASH")]
+        print(f"  {label:<12}: {len(tickers):>5} tickers")
+        return tickers
+    except Exception as e:
+        print(f"  [WARN] {label} iShares CSV failed: {e}")
+        return []
+
+
+_DJIA_FALLBACK = [
+    "AAPL", "AMGN", "AMZN", "AXP", "BA",  "CAT",  "CRM",  "CSCO", "CVX",  "DIS",
+    "DOW",  "GS",   "HD",   "HON", "IBM", "JNJ",  "JPM",  "KO",   "MCD",  "MMM",
+    "MRK",  "MSFT", "NKE",  "PG",  "SHW", "TRV",  "UNH",  "V",    "VZ",   "WMT",
+]
+
+def get_djia_tickers() -> list[str]:
+    """Live DJIA components from Wikipedia; falls back to a hardcoded list."""
+    tickers = _fetch_wikipedia_index(
+        "https://en.wikipedia.org/wiki/Dow_Jones_Industrial_Average", "DJIA")
+    if tickers:
+        return tickers
+    print("  [WARN] Using hardcoded DJIA fallback list")
+    tickers = list(dict.fromkeys(_DJIA_FALLBACK))
+    print(f"  DJIA        : {len(tickers):>5} tickers (fallback)")
+    return tickers
+
+
+# Human-readable index names exposed to the GUI
+INDEX_CHOICES = [
+    "All",
+    "All + OTC",
+    "S&P 500", "S&P 400", "S&P 600", "S&P 1500",
+    "Russell 1000", "Russell 2000", "Russell 3000",
+    "NASDAQ 100", "NASDAQ", "NYSE", "AMEX",
+    "DJIA",
+]
+
+
+def collect_tickers(index: str = "All") -> list[str]:
+    """
+    Fetch the constituent tickers for the requested index.
+
+    "All"          — every common stock on all US exchanges via NASDAQ Trader files
+    "All + OTC"    — exchange-listed + OTC/Pink Sheet stocks
+    "S&P 500/400/600/1500" — via Wikipedia / GitHub CSV
+    "Russell 1000/2000/3000" — via iShares ETF holdings CSVs
+    "NASDAQ 100"   — live Wikipedia list with hardcoded fallback
+    "NASDAQ/NYSE/AMEX" — per-exchange listings via NASDAQ Trader files
+    "DJIA"         — 30 components from Wikipedia with hardcoded fallback
+
+    Fallback chain for "All" and single-exchange lookups:
+      NASDAQ Trader files → NASDAQ screener API → SEC EDGAR → Russell 3000 → S&P 500
+    """
+    print(f"Fetching tickers for index: {index} ...")
+
+    sp400_url = "https://en.wikipedia.org/wiki/List_of_S%26P_400_companies"
+    sp600_url = "https://en.wikipedia.org/wiki/List_of_S%26P_600_companies"
+
+    def _all_exchange_tickers() -> list[str]:
+        """All exchange-listed US common stocks with full fallback chain."""
+        # 1. NASDAQ Trader official listing files (most reliable — static, no bot detection)
+        t = _fetch_nasdaqtrader_listings(exchange_filter=None)
+        if t:
+            return t
+        # 2. NASDAQ screener API (often blocked but try anyway)
+        print("  [WARN] NASDAQ Trader files failed — trying NASDAQ screener API")
+        t = []
+        for exch in ("NYSE", "NASDAQ", "AMEX"):
+            t.extend(_fetch_exchange(exch))
+        if t:
+            return t
+        # 3. SEC EDGAR company registry (~10 000+ tickers)
+        print("  [WARN] NASDAQ API failed — trying SEC EDGAR")
+        t = _fetch_sec_all_tickers()
+        if t:
+            return t
+        # 4. Russell 3000
+        print("  [WARN] SEC EDGAR failed — trying Russell 3000")
+        t = _fetch_russell("Russell 3000")
+        if t:
+            return t
+        # 5. S&P 1500
+        print("  [WARN] Russell 3000 failed — trying S&P 1500")
+        t = (_fetch_sp500()
+             + _fetch_wikipedia_index(sp400_url, "S&P 400")
+             + _fetch_wikipedia_index(sp600_url, "S&P 600"))
+        if t:
+            return t
+        # 6. S&P 500 last resort
+        print("  [WARN] All broad sources failed — falling back to S&P 500")
+        return _fetch_sp500()
+
+    if index == "All":
+        tickers = _all_exchange_tickers()
+
+    elif index == "All + OTC":
+        tickers = _all_exchange_tickers()
+        otc = _fetch_otc_tickers()
+        if otc:
+            tickers = tickers + otc
+        else:
+            print("  [WARN] OTC Markets unavailable — showing exchange-listed only")
+
+    elif index == "S&P 500":
+        tickers = _fetch_sp500()
+
+    elif index == "S&P 400":
+        tickers = _fetch_wikipedia_index(sp400_url, "S&P 400")
+
+    elif index == "S&P 600":
+        tickers = _fetch_wikipedia_index(sp600_url, "S&P 600")
+
+    elif index == "S&P 1500":
+        tickers = (_fetch_sp500()
+                   + _fetch_wikipedia_index(sp400_url, "S&P 400")
+                   + _fetch_wikipedia_index(sp600_url, "S&P 600"))
+
+    elif index in ("Russell 1000", "Russell 2000", "Russell 3000"):
+        tickers = _fetch_russell(index)
+        if not tickers:
+            print(f"  [WARN] iShares CSV failed — using full exchange listing for {index}")
+            tickers = _all_exchange_tickers()
+
+    elif index == "NASDAQ 100":
+        tickers = get_nasdaq100_tickers()
+
+    elif index == "NASDAQ":
+        tickers = _fetch_nasdaqtrader_listings(exchange_filter="NASDAQ")
+        if not tickers:
+            tickers = _fetch_exchange("NASDAQ")
+
+    elif index == "NYSE":
+        tickers = _fetch_nasdaqtrader_listings(exchange_filter="NYSE")
+        if not tickers:
+            tickers = _fetch_exchange("NYSE")
+
+    elif index == "AMEX":
+        tickers = _fetch_nasdaqtrader_listings(exchange_filter="AMEX")
+        if not tickers:
+            tickers = _fetch_exchange("AMEX")
+
+    elif index == "DJIA":
+        tickers = get_djia_tickers()
+
+    else:
+        print(f"  [WARN] Unknown index '{index}' — defaulting to All")
+        tickers = _all_exchange_tickers()
+
+    combined = list(dict.fromkeys(tickers))   # deduplicate, preserve order
+    print(f"  Total       : {len(combined):>5} unique tickers\n")
+    return combined
+
+
+# ---------------------------------------------------------------------------
+# News Sentiment (multi-source VADER)
+# ---------------------------------------------------------------------------
+# Sources pulled in order:
+#   1. Yahoo Finance   — via yfinance Ticker.news (built-in, no key)
+#   2. Google News RSS — public RSS feed, no API key required
+# ---------------------------------------------------------------------------
+
+
+def _extract_yfinance_news(ticker_obj) -> list[tuple[str, float, str, str]]:
+    """Return (title, timestamp, url, summary) tuples from yfinance Ticker.news."""
+    results = []
+    try:
+        news = ticker_obj.news or []
+        now  = time.time()
+        for item in news[:30]:
+            if not isinstance(item, dict):
+                continue
+            title = ts = url = summary = None
+            content = item.get("content", {})
+            if isinstance(content, dict) and content.get("title"):
+                title   = content["title"]
+                pub     = content.get("pubDate", "")
+                try:
+                    ts = datetime.fromisoformat(
+                        pub.replace("Z", "+00:00")).timestamp()
+                except Exception:
+                    ts = now
+                # Try several URL fields used across yfinance versions
+                canon = content.get("canonicalUrl") or {}
+                url   = (canon.get("url") if isinstance(canon, dict) else None) \
+                        or content.get("url") or content.get("clickThroughUrl", {}).get("url") \
+                        or item.get("link")
+                summary = content.get("summary") or content.get("description") or ""
+            elif item.get("title"):
+                title   = item["title"]
+                ts      = item.get("providerPublishTime", now)
+                url     = item.get("link") or item.get("url") or ""
+                summary = item.get("summary") or item.get("description") or ""
+            if title:
+                clean = re.sub(r'\s+', ' ',
+                               html.unescape(re.sub(r'<[^>]+>', ' ', summary or ""))).strip()
+                results.append((title, float(ts or now), url or "", clean))
+    except Exception:
+        pass
+    return results
+
+
+def _extract_google_news_rss(ticker: str, company_name: str = "") -> list[tuple[str, float, str, str]]:
+    """
+    Fetch headlines from Google News RSS for the given ticker.
+    Returns (title, timestamp, url, summary) tuples.
+    No API key required.
+    """
+    import re as _re
+    import xml.etree.ElementTree as ET
+    import urllib.parse
+    results = []
+    try:
+        query = f"{ticker} stock"
+        if company_name:
+            query += f" {company_name}"
+        encoded = urllib.parse.quote(query)
+        rss_url = (
+            f"https://news.google.com/rss/search"
+            f"?q={encoded}&hl=en-US&gl=US&ceid=US:en"
+        )
+        headers = {"User-Agent": "Mozilla/5.0 (compatible; StockScreener/1.0)"}
+        resp = requests.get(rss_url, headers=headers, timeout=8)
+        resp.raise_for_status()
+        root = ET.fromstring(resp.content)
+        now  = time.time()
+        for item in root.findall(".//item")[:30]:
+            title_el = item.find("title")
+            pub_el   = item.find("pubDate")
+            desc_el  = item.find("description")
+            if title_el is None or not title_el.text:
+                continue
+            title = title_el.text.strip()
+            ts    = now
+            if pub_el is not None and pub_el.text:
+                try:
+                    from email.utils import parsedate_to_datetime
+                    ts = parsedate_to_datetime(pub_el.text).timestamp()
+                except Exception:
+                    pass
+            # guid is more reliably a plain URL in Google News RSS than <link>
+            guid_el = item.find("guid")
+            link    = (guid_el.text.strip() if guid_el is not None and guid_el.text else "") \
+                      or (item.findtext("link") or "")
+            # Strip HTML tags and unescape entities from description snippet
+            raw_desc = desc_el.text if desc_el is not None and desc_el.text else ""
+            summary  = _re.sub(r'\s+', ' ',
+                               html.unescape(_re.sub(r"<[^>]+>", " ", raw_desc))).strip()
+            results.append((title, ts, link, summary))
+    except Exception:
+        pass
+    return results
+
+
+def get_news_headlines(ticker_obj, ticker: str = "", company_name: str = "") \
+        -> tuple:
+    """
+    Aggregate headlines from Yahoo Finance and Google News RSS and compute
+    recency-weighted VADER sentiment.
+
+    Returns (aggregate_score, top_headlines) where:
+      - aggregate_score is float in [-1.0, +1.0] or None
+      - top_headlines is a list of (title, vader_score, age_days) tuples,
+        sorted by impact (abs(score) × recency weight), up to 8 entries.
+    """
+    if _VADER is None:
+        return None, []
+
+    all_items: list[tuple[str, float, str, str]] = []
+    all_items.extend(_extract_yfinance_news(ticker_obj))
+    if ticker:
+        all_items.extend(_extract_google_news_rss(ticker, company_name))
+
+    if not all_items:
+        return None, []
+
+    # Deduplicate by normalised title
+    seen: set[str] = set()
+    unique: list[tuple[str, float, str, str]] = []
+    for title, ts, url, summary in all_items:
+        key = title.lower().strip()[:80]
+        if key not in seen:
+            seen.add(key)
+            unique.append((title, ts, url, summary))
+
+    now = time.time()
+    total_w = total_s = 0.0
+    # (title, score, age_days, weight, url, summary)
+    scored: list[tuple[str, float, float, float, str, str]] = []
+    for title, ts, url, summary in unique:
+        age_days = max(0.0, (now - ts) / 86400)
+        if age_days <= 7:
+            weight = 1.0
+        else:
+            weight = max(0.05, 1.0 - (age_days - 7) / 23.0)
+        score    = _VADER.polarity_scores(title)["compound"]
+        total_s += score * weight
+        total_w += weight
+        scored.append((title, score, age_days, weight, url, summary))
+
+    aggregate = total_s / total_w if total_w else None
+
+    # Top headlines by impact: abs(score) × recency weight
+    scored.sort(key=lambda x: abs(x[1]) * x[3], reverse=True)
+    top = [(title, vader_score, age_days, url, summary)
+           for title, vader_score, age_days, _, url, summary in scored[:8]]
+
+    return aggregate, top
+
+
+def _news_sentiment(ticker_obj, ticker: str = "", company_name: str = "") -> float | None:
+    """Backward-compatible wrapper — returns only the aggregate score."""
+    score, _ = get_news_headlines(ticker_obj, ticker=ticker, company_name=company_name)
+    return score
+
+
+# ---------------------------------------------------------------------------
+# EDGAR Bulk Fundamentals
+# ---------------------------------------------------------------------------
+# Fetches financial statement data for all US public companies from the
+# SEC EDGAR XBRL frames API.  One HTTP call per financial concept returns
+# values for ALL filers simultaneously — ~50 calls cover every metric
+# needed for the scoring model in roughly 2 minutes.
+#
+# Coverage: ~85–90% of exchange-listed US stocks.  Tickers with no EDGAR
+# coverage still appear in results and score on price/momentum/analyst
+# data only; their fundamental fields default to NaN.
+# ---------------------------------------------------------------------------
+
+_EDGAR_FRAMES  = "https://data.sec.gov/api/xbrl/frames"
+_EDGAR_TICKERS = "https://www.sec.gov/files/company_tickers.json"
+_EDGAR_UA      = {"User-Agent": "StockScreener contact@investmenttool.com"}
+_FRAME_CACHE: dict = {}   # in-memory cache so the same frame is never fetched twice
+
+
+def _get_recent_quarters(n: int = 9) -> list[tuple[int, int]]:
+    """
+    Return the last n (year, quarter) tuples, most-recent first, using a
+    45-day filing lag so we only request periods most companies have filed.
+    """
+    from datetime import date, timedelta as _td
+    ref = date.today() - _td(days=45)
+    y, q = ref.year, (ref.month - 1) // 3 + 1
+    out  = []
+    for _ in range(n):
+        out.append((y, q))
+        q -= 1
+        if q == 0:
+            q, y = 4, y - 1
+    return out
+
+
+def _fetch_one_frame(concept: str, unit: str, period: str) -> dict[int, float]:
+    """
+    Fetch all companies' values for one EDGAR XBRL concept/period.
+    Returns {cik (int): value (float)}.  Results are cached in _FRAME_CACHE
+    so the same concept/period is never downloaded twice in one run.
+    """
+    key = (concept, unit, period)
+    if key in _FRAME_CACHE:
+        return _FRAME_CACHE[key]
+    url = f"{_EDGAR_FRAMES}/us-gaap/{concept}/{unit}/{period}.json"
+    try:
+        resp = requests.get(url, headers=_EDGAR_UA, timeout=20)
+        if resp.status_code == 404:
+            _FRAME_CACHE[key] = {}
+            return {}
+        resp.raise_for_status()
+        result: dict[int, float] = {}
+        for row in resp.json().get("data", []):
+            # The EDGAR frames API returns each row as a dict with keys:
+            # accn, cik, entityName, loc, start, end, val
+            # (Not as a list — handle both formats for safety.)
+            try:
+                if isinstance(row, dict):
+                    cik = int(row["cik"])
+                    val = float(row["val"])
+                else:
+                    # Legacy/alternative format: [accn, cik, entityName, loc, end, val]
+                    if len(row) < 6:
+                        continue
+                    cik = int(row[1])
+                    val = float(row[5])
+                result[cik] = val   # last entry wins (restatements)
+            except (KeyError, TypeError, ValueError):
+                continue
+        _FRAME_CACHE[key] = result
+        time.sleep(0.15)   # stay comfortably under SEC's 10 req/sec limit
+        return result
+    except Exception:
+        _FRAME_CACHE[key] = {}
+        return {}
+
+
+def _sum_frames(concepts: list[str], unit: str,
+                periods: list[str]) -> dict[int, float]:
+    """
+    Sum values across periods (TTM) trying each concept in order.
+    The primary concept is tried first; gaps are filled by fallback concepts.
+    """
+    ttm: dict[int, dict] = {}   # {cik: {period: value}}
+    for concept in concepts:
+        for period in periods:
+            for cik, val in _fetch_one_frame(concept, unit, period).items():
+                ttm.setdefault(cik, {})
+                if period not in ttm[cik]:
+                    ttm[cik][period] = val
+    return {cik: sum(pv.values()) for cik, pv in ttm.items()}
+
+
+def _best_frame(concepts: list[str], unit: str,
+                periods: list[str]) -> dict[int, float]:
+    """
+    Return the most-recent available value per CIK (for balance-sheet items).
+    Iterates periods most-recent first; first value found for each CIK wins.
+    """
+    best: dict[int, float] = {}
+    for concept in concepts:
+        for period in periods:
+            for cik, val in _fetch_one_frame(concept, unit, period).items():
+                if cik not in best:
+                    best[cik] = val
+    return best
+
+
+def _build_cik_maps() -> tuple[dict[int, str], dict[int, str]]:
+    """
+    Fetch SEC company_tickers.json and return:
+      cik_to_ticker — {cik_int: "AAPL"}
+      cik_to_name   — {cik_int: "Apple Inc."}
+    """
+    try:
+        resp = requests.get(_EDGAR_TICKERS, headers=_EDGAR_UA, timeout=20)
+        resp.raise_for_status()
+        data = resp.json()
+        return (
+            {int(v["cik_str"]): v["ticker"].upper() for v in data.values()},
+            {int(v["cik_str"]): v["title"]          for v in data.values()},
+        )
+    except Exception as e:
+        print(f"  [WARN] CIK map unavailable: {e}")
+        return {}, {}
+
+
+def _fetch_edgar_bulk(close_map: dict[str, pd.Series]) -> dict[str, dict]:
+    """
+    Fetch fundamental data for all tickers from the EDGAR XBRL frames API.
+    Returns {ticker: {field: value}} with keys matching the rest of the
+    scoring pipeline.  Takes ~2 minutes for the full US universe.
+
+    Fields returned (NaN-safe — missing values simply absent from the dict):
+      market_cap, pe_trailing, pb_ratio, ev_ebitda, eps_trailing,
+      revenue, revenue_growth, earnings_growth, roe, roa,
+      debt_to_equity, total_debt, total_cash, book_value, current_ratio,
+      profit_margin, operating_margin, fcf_yield, name
+    """
+    print("Phase 2A: Fetching EDGAR bulk fundamentals ...")
+    cik_to_ticker, cik_to_name = _build_cik_maps()
+    if not cik_to_ticker:
+        print("  [WARN] CIK map unavailable — EDGAR bulk skipped")
+        return {}
+
+    quarters    = _get_recent_quarters(9)
+    ttm_periods = [f"CY{y}Q{q}"  for y, q in quarters[:4]]
+    prev_periods= [f"CY{y}Q{q}"  for y, q in quarters[4:8]]
+    bs_periods  = [f"CY{y}Q{q}I" for y, q in quarters[:3]]
+
+    print(f"  TTM  : {ttm_periods}")
+    print(f"  BS   : {bs_periods[0]} (+{len(bs_periods)-1} fallback periods)")
+
+    # ── Balance sheet (most recent available quarter) ──────────────────────
+    assets     = _best_frame(["Assets"],                                           "USD",    bs_periods)
+    equity     = _best_frame(["StockholdersEquity",
+                               "StockholdersEquityIncludingPortionAttributable"
+                               "ToNoncontrollingInterest"],                        "USD",    bs_periods)
+    cur_assets = _best_frame(["AssetsCurrent"],                                    "USD",    bs_periods)
+    cur_liab   = _best_frame(["LiabilitiesCurrent"],                               "USD",    bs_periods)
+    cash       = _best_frame(["CashAndCashEquivalentsAtCarryingValue",
+                               "CashCashEquivalentsAndShortTermInvestments"],      "USD",    bs_periods)
+    lt_debt    = _best_frame(["LongTermDebt", "LongTermDebtNoncurrent",
+                               "LongTermDebtAndCapitalLeaseObligations"],          "USD",    bs_periods)
+    shares     = _best_frame(["CommonStockSharesOutstanding"],                     "shares", bs_periods)
+
+    # ── Income statement TTM ────────────────────────────────────────────────
+    revenue    = _sum_frames(["Revenues",
+                               "RevenueFromContractWithCustomer"
+                               "ExcludingAssessedTax",
+                               "SalesRevenueNet"],                                 "USD", ttm_periods)
+    net_income = _sum_frames(["NetIncomeLoss"],                                    "USD", ttm_periods)
+    op_income  = _sum_frames(["OperatingIncomeLoss"],                              "USD", ttm_periods)
+    dna        = _sum_frames(["DepreciationDepletionAndAmortization",
+                               "DepreciationAndAmortization"],                     "USD", ttm_periods)
+
+    # ── Cash flow TTM ───────────────────────────────────────────────────────
+    op_cf  = _sum_frames(["NetCashProvidedByUsedInOperatingActivities"],           "USD", ttm_periods)
+    capex  = _sum_frames(["PaymentsToAcquirePropertyPlantAndEquipment"],           "USD", ttm_periods)
+
+    # ── Prior-year TTM for growth rates ────────────────────────────────────
+    rev_prev   = _sum_frames(["Revenues",
+                               "RevenueFromContractWithCustomer"
+                               "ExcludingAssessedTax",
+                               "SalesRevenueNet"],                                 "USD", prev_periods)
+    ni_prev    = _sum_frames(["NetIncomeLoss"],                                    "USD", prev_periods)
+
+    print(f"  Revenue data  : {len(revenue)} companies")
+
+    # ── Assemble per-ticker records ─────────────────────────────────────────
+    valid_set = set(close_map.keys())
+    result: dict[str, dict] = {}
+
+    for cik, ticker in cik_to_ticker.items():
+        if ticker not in valid_set:
+            continue
+
+        price = float(close_map[ticker].iloc[-1])
+
+        rev   = revenue.get(cik);    ni    = net_income.get(cik)
+        op_i  = op_income.get(cik);  d_a   = dna.get(cik)
+        ocf   = op_cf.get(cik);      cx    = capex.get(cik)
+        tot_a = assets.get(cik);     eq    = equity.get(cik)
+        ca    = cur_assets.get(cik); cl    = cur_liab.get(cik)
+        csh   = cash.get(cik);       ltd   = lt_debt.get(cik)
+        sh    = shares.get(cik)
+        r_p   = rev_prev.get(cik);   n_p   = ni_prev.get(cik)
+
+        mkt_cap   = (price * sh)              if sh and sh > 0           else None
+        eps_trail = (ni / sh)                 if ni is not None and sh and sh > 0 else None
+        pe_trail  = (price / eps_trail)       if eps_trail and eps_trail > 0       else None
+        pb        = (price / (eq / sh))       if eq and sh and sh > 0 and eq > 0   else None
+        ebitda    = ((op_i + d_a)             if op_i is not None and d_a is not None else op_i)
+        ev        = ((mkt_cap + (ltd or 0) - (csh or 0)) if mkt_cap is not None    else None)
+        ev_ebitda = (ev / ebitda)             if ev and ebitda and ebitda > 0       else None
+        roe       = (ni / eq)                 if ni is not None and eq and eq > 0   else None
+        roa       = (ni / tot_a)              if ni is not None and tot_a and tot_a > 0 else None
+        de        = (ltd / eq)                if ltd is not None and eq and eq > 0  else None
+        curr_r    = (ca / cl)                 if ca and cl and cl > 0               else None
+        pm        = (ni / rev)                if ni is not None and rev and rev > 0 else None
+        om        = (op_i / rev)              if op_i is not None and rev and rev > 0 else None
+        fcf       = ((ocf - cx)               if ocf is not None and cx is not None else ocf)
+        fcf_yield = (fcf / mkt_cap)           if fcf is not None and mkt_cap and mkt_cap > 0 else None
+        rev_g     = ((rev - r_p) / abs(r_p)   if rev is not None and r_p and r_p != 0 else None)
+        ni_g      = ((ni  - n_p) / abs(n_p)   if ni  is not None and n_p and n_p != 0 else None)
+
+        result[ticker] = {
+            "name":             cik_to_name.get(cik, ticker),
+            "sector":           "N/A",
+            "industry":         "N/A",
+            "market_cap":       mkt_cap,
+            "pe_trailing":      pe_trail,
+            "pb_ratio":         pb,
+            "ev_ebitda":        ev_ebitda,
+            "eps_trailing":     eps_trail,
+            "revenue":          rev,
+            "revenue_growth":   rev_g,
+            "earnings_growth":  ni_g,
+            "roe":              roe,
+            "roa":              roa,
+            "debt_to_equity":   de,
+            "total_debt":       ltd,
+            "total_cash":       csh,
+            "book_value":       eq,
+            "current_ratio":    curr_r,
+            "profit_margin":    pm,
+            "operating_margin": om,
+            "fcf_yield":        fcf_yield,
+        }
+
+    print(f"  EDGAR matched : {len(result)} tickers\n")
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Analyst + News Cache (Supabase)
+# ---------------------------------------------------------------------------
+
+try:
+    from license_check import _SUPABASE_URL as _SB_URL, _SUPABASE_ANON as _SB_ANON
+except ImportError:
+    _SB_URL = _SB_ANON = None
+
+
+def _load_analyst_cache() -> dict[str, dict]:
+    """
+    Load analyst consensus and news sentiment from the Supabase cache table.
+    Returns {ticker: {field: value}} or {} on any failure.
+    Warns (but still proceeds) if cache data is more than 48 hours old.
+    """
+    if not _SB_URL or not _SB_ANON:
+        print("  [WARN] Supabase config unavailable — analyst cache skipped")
+        return {}
+    try:
+        resp = requests.get(
+            f"{_SB_URL}/rest/v1/analyst_cache"
+            "?select=ticker,pe_forward,eps_forward,analyst_norm,analyst_upside,"
+            "analyst_count,analyst_target,recommendation,news_sentiment,"
+            "sector,industry,updated_at"
+            "&limit=20000",
+            headers={"apikey": _SB_ANON, "Content-Type": "application/json"},
+            timeout=20,
+        )
+        resp.raise_for_status()
+        rows = resp.json()
+        if not rows:
+            print("  [WARN] Analyst cache is empty — analyst scores will be neutral")
+            return {}
+
+        valid_ts = [r["updated_at"] for r in rows if r.get("updated_at")]
+        if valid_ts:
+            age_h = (
+                datetime.now(timezone.utc)
+                - datetime.fromisoformat(max(valid_ts).replace("Z", "+00:00"))
+            ).total_seconds() / 3600
+            if age_h > 48:
+                print(f"  [WARN] Analyst cache is {age_h:.0f}h old "
+                      "(refresh runs tonight)")
+            else:
+                print(f"  Analyst cache : {len(rows)} tickers  "
+                      f"(updated {age_h:.1f}h ago)")
+
+        return {r["ticker"]: r for r in rows}
+    except Exception as e:
+        print(f"  [WARN] Could not load analyst cache: {e}")
+        return {}
+
+
+# ---------------------------------------------------------------------------
+# FINRA Short Interest
+# ---------------------------------------------------------------------------
+
+def _fetch_finra_short() -> dict[str, float]:
+    """
+    Download the FINRA RegSHO daily short-volume file.
+    Returns {ticker: short_volume_ratio} where ratio = short_vol / total_vol.
+
+    This is a short-volume ratio, not short % of float, but it is a reliable
+    intraday bearish-pressure signal and a suitable proxy for the Risk score.
+    Files are published each trading day at:
+      https://cdn.finra.org/equity/regsho/daily/
+    """
+    from datetime import date as _date, timedelta as _td
+    for days_back in range(1, 6):
+        d = _date.today() - _td(days=days_back)
+        if d.weekday() >= 5:   # skip Saturday / Sunday
+            continue
+        url = (
+            "https://cdn.finra.org/equity/regsho/daily/"
+            f"CNMSshvol{d.strftime('%Y%m%d')}.txt"
+        )
+        try:
+            resp = requests.get(url, headers=_HTTP_HEADERS, timeout=15)
+            if resp.status_code == 404:
+                continue
+            resp.raise_for_status()
+            result: dict[str, float] = {}
+            for line in resp.text.splitlines()[1:]:
+                parts = line.split("|")
+                if len(parts) < 4:
+                    continue
+                try:
+                    sv = float(parts[1]);  tv = float(parts[3])
+                    if tv > 0:
+                        result[parts[0].strip()] = sv / tv
+                except (ValueError, IndexError):
+                    continue
+            if result:
+                print(f"  FINRA short   : {len(result)} tickers ({d})")
+                return result
+        except Exception:
+            continue
+    print("  [WARN] FINRA short interest unavailable")
+    return {}
+
+
+# ---------------------------------------------------------------------------
+# Beta Calculation
+# ---------------------------------------------------------------------------
+
+def _calc_beta_map(close_map: dict[str, pd.Series],
+                   start_date: str) -> dict[str, float]:
+    """
+    Calculate 1-year beta vs SPY for every ticker in close_map.
+    Downloads SPY history once, then computes cov(stock, SPY) / var(SPY)
+    in pandas — pure vectorised math, takes ~10–30 seconds for 6,500 tickers.
+    """
+    try:
+        spy_raw = yf.download("SPY", start=start_date,
+                               auto_adjust=True, progress=False)
+        if spy_raw is None or spy_raw.empty:
+            return {}
+        spy_col = next(
+            (c for c in ("Close", "Adj Close") if c in spy_raw.columns), None
+        )
+        if not spy_col:
+            return {}
+        spy_close = spy_raw[spy_col]
+        # Newer yfinance returns MultiIndex columns even for single tickers —
+        # squeeze a single-column DataFrame to a Series.
+        if isinstance(spy_close, pd.DataFrame):
+            spy_close = spy_close.squeeze(axis=1)
+        spy_ret = spy_close.dropna().pct_change().dropna()
+
+        beta_map: dict[str, float] = {}
+        for ticker, close in close_map.items():
+            try:
+                s_ret  = close.pct_change().dropna()
+                common = s_ret.index.intersection(spy_ret.index)
+                if len(common) < 50:
+                    continue
+                m     = spy_ret.loc[common]
+                var_m = float(m.var())
+                if var_m > 0:
+                    beta_map[ticker] = float(s_ret.loc[common].cov(m) / var_m)
+            except Exception:
+                continue
+        print(f"  Beta          : {len(beta_map)} tickers calculated")
+        return beta_map
+    except Exception as e:
+        print(f"  [WARN] Beta calculation failed: {e}")
+        return {}
+
+
+# ---------------------------------------------------------------------------
+# Data Fetching
+# ---------------------------------------------------------------------------
+
+# Sentinel so the rest of the file still compiles if something references these
+_yf_session = None
+_yf_crumb   = None
+
+
+def _download_history_batch(tickers: list[str], start: str) -> dict[str, pd.Series]:
+    """
+    Download price history for a batch of tickers via yf.download().
+    yfinance manages cookies and crumb internally — no custom auth needed.
+    Returns {ticker: Close Series} for tickers with ≥ 20 trading days.
+    """
+    if not tickers:
+        return {}
+    result: dict[str, pd.Series] = {}
+    try:
+        # yf.download handles auth/crumb internally
+        raw = yf.download(
+            tickers if len(tickers) > 1 else tickers[0],
+            start=start,
+            auto_adjust=True,
+            progress=False,
+        )
+        if raw is None or raw.empty:
+            return result
+
+        if len(tickers) == 1:
+            # Single ticker — newer yfinance returns MultiIndex columns even for
+            # a single ticker, so raw["Close"] may be a single-column DataFrame.
+            # Squeeze it to a Series so downstream float(close.iloc[-1]) works.
+            t = tickers[0]
+            col = next((c for c in ("Close", "Adj Close") if c in raw.columns), None)
+            if col:
+                s = raw[col]
+                if isinstance(s, pd.DataFrame):
+                    s = s.squeeze(axis=1)   # DataFrame → Series
+                s = s.dropna()
+                if len(s) >= 20:
+                    result[t] = s
+        else:
+            # Multiple tickers → MultiIndex columns
+            cols = raw.columns
+            if isinstance(cols, pd.MultiIndex):
+                lvl0 = cols.get_level_values(0)
+                if "Close" in lvl0:
+                    close_df = raw["Close"]
+                    for t in tickers:
+                        if t in close_df.columns:
+                            s = close_df[t].dropna()
+                            if len(s) >= 20:
+                                result[t] = s
+                else:
+                    # (ticker, field) layout used by some yfinance versions
+                    for t in tickers:
+                        if t in lvl0:
+                            try:
+                                sub = raw[t]
+                                col = next((c for c in ("Close", "Adj Close")
+                                            if c in sub.columns), None)
+                                if col:
+                                    s = sub[col].dropna()
+                                    if len(s) >= 20:
+                                        result[t] = s
+                            except (KeyError, TypeError):
+                                pass
+    except Exception as e:
+        print(f"\n  [WARN] yf.download batch failed: {e}")
+    return result
+
+
+def _fetch_fundamentals(
+    ticker: str,
+    close: pd.Series,
+    sector_filter: tuple | None = None,
+    mktcap_range: tuple | None = None,
+) -> dict | None:
+    """
+    Fetch fundamental/analyst/sentiment data for one ticker via yf.Ticker.
+    yfinance handles all Yahoo Finance auth internally.
+    Price history is supplied from Phase 1 so we only need the info call.
+
+    sector_filter: (column, value) tuple — e.g. ("sector", "Technology") or
+                   ("industry", "Aerospace & Defense").  None = no filter.
+    mktcap_range:  (min, max) in dollars, either bound may be None.
+    """
+    # Small random delay to spread concurrent worker requests
+    time.sleep(random.uniform(0.0, 1.0))
+    try:
+        stock = yf.Ticker(ticker)
+        info  = stock.info
+
+        if not info or not isinstance(info, dict) or len(info) < 3:
+            return None
+
+        # ── Screen-time sector filter ──────────────────────────────────────
+        if sector_filter is not None:
+            col, val = sector_filter
+            actual = info.get("sector") if col == "sector" else info.get("industry")
+            if actual != val:
+                return None
+
+        # ── Screen-time market-cap filter ──────────────────────────────────
+        if mktcap_range is not None:
+            try:
+                mkt = float(info.get("marketCap") or 0)
+            except (TypeError, ValueError):
+                mkt = 0.0
+            lo, hi = mktcap_range
+            if lo is not None and mkt < lo:
+                return None
+            if hi is not None and mkt >= hi:
+                return None
+
+        price_now = float(close.iloc[-1])
+
+        def pct_return(days_back: int) -> float | None:
+            idx  = max(0, len(close) - days_back)
+            past = float(close.iloc[idx])
+            return (price_now - past) / past if past > 0 else None
+
+        returns_30d = close.iloc[-30:].pct_change().dropna()
+        volatility  = float(returns_30d.std() * (252 ** 0.5)) if len(returns_30d) >= 5 else None
+
+        try:
+            rec_mean = float(info.get("recommendationMean")) if info.get("recommendationMean") is not None else None
+        except (TypeError, ValueError):
+            rec_mean = None
+        analyst_norm   = (5.0 - rec_mean) / 4.0 if rec_mean is not None and 1 <= rec_mean <= 5 else None
+        try:
+            target_price = float(info.get("targetMeanPrice")) if info.get("targetMeanPrice") is not None else None
+        except (TypeError, ValueError):
+            target_price = None
+        analyst_upside = (target_price / price_now - 1.0
+                          if target_price is not None and price_now > 0 else None)
+
+        try:
+            fcf = float(info.get("freeCashflow")) if info.get("freeCashflow") is not None else None
+        except (TypeError, ValueError):
+            fcf = None
+        try:
+            mkt = float(info.get("marketCap")) if info.get("marketCap") is not None else None
+        except (TypeError, ValueError):
+            mkt = None
+        fcf_yield = (fcf / mkt) if fcf is not None and mkt is not None and mkt > 0 else None
+
+        company_name = info.get("longName", "")
+        news_sent, news_headlines = get_news_headlines(stock, ticker=ticker, company_name=company_name)
+
+        return {
+            "ticker":           ticker,
+            "name":             info.get("longName", ticker),
+            "sector":           info.get("sector",   "N/A"),
+            "industry":         info.get("industry", "N/A"),
+            "price":            price_now,
+            "pe_forward":       info.get("forwardPE"),
+            "pe_trailing":      info.get("trailingPE"),
+            "pb_ratio":         info.get("priceToBook"),
+            "ev_ebitda":        info.get("enterpriseToEbitda"),
+            "revenue_growth":   info.get("revenueGrowth"),
+            "earnings_growth":  info.get("earningsGrowth"),
+            "eps_forward":      info.get("forwardEps"),
+            "eps_trailing":     info.get("trailingEps"),
+            "ret_1m":           pct_return(21),
+            "ret_3m":           pct_return(63),
+            "ret_6m":           pct_return(126),
+            "ret_12m":          pct_return(252),
+            "roe":              info.get("returnOnEquity"),
+            "roa":              info.get("returnOnAssets"),
+            "debt_to_equity":   info.get("debtToEquity"),
+            "total_debt":       info.get("totalDebt"),
+            "total_cash":       info.get("totalCash"),
+            "book_value":       info.get("bookValue"),
+            "current_ratio":    info.get("currentRatio"),
+            "profit_margin":    info.get("profitMargins"),
+            "operating_margin": info.get("operatingMargins"),
+            "fcf_yield":        fcf_yield,
+            "news_sentiment":   news_sent,
+            "news_headlines":   news_headlines,
+            "analyst_norm":     analyst_norm,
+            "analyst_upside":   analyst_upside,
+            "analyst_count":    info.get("numberOfAnalystOpinions"),
+            "analyst_target":   target_price,
+            "recommendation":   info.get("recommendationKey", "N/A"),
+            "short_percent":    info.get("shortPercentOfFloat"),
+            "beta":             info.get("beta"),
+            "volatility_30d":   volatility,
+            "market_cap":       info.get("marketCap"),
+            "52w_high":         info.get("fiftyTwoWeekHigh"),
+            "52w_low":          info.get("fiftyTwoWeekLow"),
+            "dividend_yield":   info.get("dividendYield"),
+            "revenue":          info.get("totalRevenue"),
+            "business_summary": info.get("longBusinessSummary", "") or "",
+        }
+    except Exception:
+        return None
+
+
+def fetch_all(
+    tickers: list[str],
+    max_workers: int = 5,
+    screen_filters: dict | None = None,
+) -> pd.DataFrame:
+    """
+    Multi-source data fetch replacing the old per-ticker yf.Ticker.info loop.
+
+    Phase 1  — yf.download() batch price history (unchanged, ~7 min)
+    Phase 2A — EDGAR XBRL frames: bulk fundamentals for all tickers (~2 min)
+    Phase 2B — Supabase analyst_cache: analyst consensus + news sentiment (~2s)
+    Phase 2C — FINRA RegSHO daily file: short-volume ratios (~5s)
+    Phase 2D — Beta calculated locally vs SPY from price history (~20s)
+    Phase 3  — Assemble one record per ticker, apply any active filters
+
+    Tickers with no EDGAR coverage (typically micro/nano-cap OTC stocks) still
+    appear in results — they score on price momentum, risk, and analyst data;
+    fundamental fields default to NaN and receive the 50-point neutral score.
+
+    screen_filters keys (all optional):
+      sector_filter  (col, val) tuple | None
+      mktcap_range   (lo, hi)   tuple | None
+    """
+    filters    = screen_filters or {}
+    total      = len(tickers)
+    start_date = (datetime.today() - timedelta(days=380)).strftime("%Y-%m-%d")
+    start_time = time.time()
+
+    # ── Phase 1: batch price history ──────────────────────────────────────
+    print(f"Phase 1: downloading price history for {total} tickers ...")
+    close_map: dict[str, pd.Series] = {}
+
+    for i in range(0, total, HIST_BATCH):
+        batch  = tickers[i: i + HIST_BATCH]
+        closes = _download_history_batch(batch, start_date)
+        close_map.update(closes)
+        scanned = min(i + HIST_BATCH, total)
+        print(
+            f"\r  {scanned}/{total} scanned  valid={len(close_map)}"
+            f"  ({scanned / total * 100:.0f}%)   ",
+            end="", flush=True,
+        )
+        if i + HIST_BATCH < total:
+            time.sleep(HIST_PAUSE)
+
+    valid = list(close_map.keys())
+    print(f"\n  Phase 1 done — {len(valid)}/{total} tickers have price history.\n")
+
+    if not valid:
+        print("  [WARN] yf.download returned no data; trying individual history calls ...")
+        for t in tickers[:500]:
+            try:
+                hist = yf.Ticker(t).history(start=start_date, auto_adjust=True)
+                if not hist.empty and len(hist) >= 20:
+                    col = "Close" if "Close" in hist.columns else "Adj Close"
+                    if col in hist.columns:
+                        s = hist[col].dropna()
+                        if len(s) >= 20:
+                            close_map[t] = s
+            except Exception:
+                pass
+            time.sleep(random.uniform(0.3, 0.7))
+        valid = list(close_map.keys())
+        if not valid:
+            print("ERROR: No tickers returned valid price history.")
+            return pd.DataFrame()
+        print(f"  Fallback found {len(valid)} tickers with history.\n")
+
+    # ── Phase 2A: EDGAR bulk fundamentals ─────────────────────────────────
+    edgar_data = _fetch_edgar_bulk(close_map)
+
+    # ── Phase 2B: Analyst + news cache from Supabase ──────────────────────
+    print("Phase 2B: Loading analyst cache ...")
+    analyst_cache = _load_analyst_cache()
+
+    # ── Phase 2C: FINRA short-volume ratios ───────────────────────────────
+    print("Phase 2C: Fetching FINRA short interest ...")
+    finra_short = _fetch_finra_short()
+
+    # ── Phase 2D: Beta vs SPY ─────────────────────────────────────────────
+    print("Phase 2D: Calculating beta ...")
+    beta_map = _calc_beta_map(close_map, start_date)
+
+    # ── Phase 3: assemble per-ticker records ──────────────────────────────
+    sector_filter = filters.get("sector_filter")
+    mktcap_range  = filters.get("mktcap_range")
+    results: list[dict] = []
+
+    filter_labels = []
+    if sector_filter:
+        filter_labels.append(f"sector={sector_filter[1]}")
+    if mktcap_range:
+        lo, hi = mktcap_range
+        filter_labels.append(
+            f"mktcap={'$'+str(int(lo//1e9))+'B+' if lo else ''}"
+            f"{'–$'+str(int(hi//1e9))+'B' if hi else ''}"
+        )
+    filter_note = f"  [{', '.join(filter_labels)}]" if filter_labels else ""
+    print(f"\nPhase 3: assembling {len(valid)} records{filter_note} ...")
+
+    for ticker in valid:
+        close   = close_map[ticker]
+        edgar   = edgar_data.get(ticker, {})
+        analyst = analyst_cache.get(ticker, {})
+
+        price_now = float(close.iloc[-1])
+
+        def pct_return(days_back: int) -> float | None:
+            idx  = max(0, len(close) - days_back)
+            past = float(close.iloc[idx])
+            return (price_now - past) / past if past > 0 else None
+
+        returns_30d = close.iloc[-30:].pct_change().dropna()
+        volatility  = (float(returns_30d.std() * (252 ** 0.5))
+                       if len(returns_30d) >= 5 else None)
+
+        mkt_cap = edgar.get("market_cap")
+
+        # ── Filters ───────────────────────────────────────────────────────
+        if sector_filter is not None:
+            col, val = sector_filter
+            field    = "sector" if col == "sector" else "industry"
+            actual   = analyst.get(field) or edgar.get(field, "N/A")
+            if actual != val:
+                continue
+        if mktcap_range is not None:
+            lo, hi = mktcap_range
+            mkt    = float(mkt_cap or 0)
+            if lo is not None and mkt < lo:
+                continue
+            if hi is not None and mkt >= hi:
+                continue
+
+        # ── Analyst fields ────────────────────────────────────────────────
+        analyst_target = analyst.get("analyst_target")
+        analyst_upside = analyst.get("analyst_upside")
+        if analyst_upside is None and analyst_target and price_now > 0:
+            try:
+                analyst_upside = float(analyst_target) / price_now - 1.0
+            except (TypeError, ValueError):
+                analyst_upside = None
+
+        results.append({
+            "ticker":           ticker,
+            "name":             edgar.get("name", ticker),
+            "sector":           analyst.get("sector")   or edgar.get("sector",   "N/A"),
+            "industry":         analyst.get("industry") or edgar.get("industry", "N/A"),
+            "price":            price_now,
+            # Valuation
+            "pe_forward":       analyst.get("pe_forward"),
+            "pe_trailing":      edgar.get("pe_trailing"),
+            "pb_ratio":         edgar.get("pb_ratio"),
+            "ev_ebitda":        edgar.get("ev_ebitda"),
+            # Growth
+            "revenue_growth":   edgar.get("revenue_growth"),
+            "earnings_growth":  edgar.get("earnings_growth"),
+            "eps_forward":      analyst.get("eps_forward"),
+            "eps_trailing":     edgar.get("eps_trailing"),
+            # Momentum (price-derived)
+            "ret_1m":           pct_return(21),
+            "ret_3m":           pct_return(63),
+            "ret_6m":           pct_return(126),
+            "ret_12m":          pct_return(252),
+            # Quality
+            "roe":              edgar.get("roe"),
+            "roa":              edgar.get("roa"),
+            "debt_to_equity":   edgar.get("debt_to_equity"),
+            "total_debt":       edgar.get("total_debt"),
+            "total_cash":       edgar.get("total_cash"),
+            "book_value":       edgar.get("book_value"),
+            "current_ratio":    edgar.get("current_ratio"),
+            # Profitability
+            "profit_margin":    edgar.get("profit_margin"),
+            "operating_margin": edgar.get("operating_margin"),
+            "fcf_yield":        edgar.get("fcf_yield"),
+            # Sentiment (from nightly cache)
+            "news_sentiment":   analyst.get("news_sentiment"),
+            "news_headlines":   [],
+            # Analyst (from nightly cache)
+            "analyst_norm":     analyst.get("analyst_norm"),
+            "analyst_upside":   analyst_upside,
+            "analyst_count":    analyst.get("analyst_count"),
+            "analyst_target":   analyst_target,
+            "recommendation":   analyst.get("recommendation", "N/A"),
+            # Risk
+            "short_percent":    finra_short.get(ticker),
+            "beta":             beta_map.get(ticker),
+            "volatility_30d":   volatility,
+            # Market data
+            "market_cap":       mkt_cap,
+            "52w_high":         float(close.max()),
+            "52w_low":          float(close.min()),
+            "dividend_yield":   None,
+            "revenue":          edgar.get("revenue"),
+            "business_summary": "",
+        })
+
+    print(f"\nDone. Assembled {len(results)} stocks in"
+          f" {time.time() - start_time:.0f}s.\n")
+
+    df = pd.DataFrame(results)
+    if not df.empty:
+        df = df.drop_duplicates(subset=["ticker"], keep="first").reset_index(drop=True)
+    return df
+
+
+# ---------------------------------------------------------------------------
+# Scoring
+# ---------------------------------------------------------------------------
+
+def _abs_score(v, breakpoints: list, default: float = 50.0) -> float:
+    """
+    Piecewise-linear interpolation of a scalar value v against a list of
+    (metric_value, score) breakpoints sorted by metric_value ascending.
+    Returns `default` when v is NaN/None.
+
+    Example: breakpoints=[(0,0),(10,50),(20,100)]
+        v=5  → 25.0
+        v=15 → 75.0
+        v=25 → 100.0 (clamped)
+    """
+    if not breakpoints:
+        return default
+    if v is None:
+        return default
+    try:
+        if np.isnan(v):
+            return default
+    except (TypeError, ValueError):
+        return default
+    pts = breakpoints
+    if v <= pts[0][0]:
+        return float(pts[0][1])
+    if v >= pts[-1][0]:
+        return float(pts[-1][1])
+    for i in range(len(pts) - 1):
+        x0, y0 = pts[i]
+        x1, y1 = pts[i + 1]
+        if x0 <= v <= x1:
+            t = (v - x0) / (x1 - x0)
+            return float(y0 + t * (y1 - y0))
+    return default
+
+
+def _score_series(series: pd.Series, breakpoints: list, default: float = 50.0) -> pd.Series:
+    """Apply _abs_score element-wise to a Series."""
+    return series.apply(lambda v: _abs_score(v, breakpoints, default))
+
+
+def compute_value_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Value Score — how attractively priced is the stock on absolute terms.
+    Lower multiples = better value = higher score.
+    P/E: <10 excellent, 15 good, 25 fair, 40+ expensive
+    P/B: <1 excellent, 2 good, 4 fair, 8+ expensive
+    EV/EBITDA: <6 excellent, 10 good, 18 fair, 30+ expensive
+    """
+    pe = df["pe_forward"].combine_first(df["pe_trailing"]).where(lambda x: x > 0)
+    pe_pts  = [(5, 100), (10, 85), (15, 70), (20, 55), (25, 40), (35, 20), (50, 5)]
+    pb_pts  = [(0.5, 100), (1.0, 85), (2.0, 70), (3.0, 55), (4.0, 40), (6.0, 20), (10.0, 5)]
+    ev_pts  = [(4, 100), (6, 85), (10, 70), (14, 55), (18, 40), (25, 20), (35, 5)]
+    return (
+        _score_series(pe,               pe_pts) * 0.40 +
+        _score_series(df["pb_ratio"],   pb_pts) * 0.30 +
+        _score_series(df["ev_ebitda"],  ev_pts) * 0.30
+    )
+
+
+def compute_growth_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Growth Score — how fast is the business expanding.
+    Revenue/earnings growth as decimals (0.10 = 10%).
+    Negative growth penalised; hyper-growth (>50%) excellent.
+    """
+    eps_delta = df["eps_forward"] - df["eps_trailing"]
+    rev_pts = [(-0.10, 5), (0.0, 20), (0.05, 40), (0.10, 55), (0.20, 70), (0.30, 85), (0.50, 100)]
+    ear_pts = [(-0.15, 5), (0.0, 20), (0.05, 38), (0.10, 55), (0.20, 70), (0.35, 85), (0.55, 100)]
+    eps_pts = [(-2.0, 5),  (0.0, 30), (0.25, 50), (0.50, 65), (1.0, 80),  (2.0, 92),  (3.0, 100)]
+    return (
+        _score_series(df["revenue_growth"],  rev_pts) * 0.40 +
+        _score_series(df["earnings_growth"], ear_pts) * 0.40 +
+        _score_series(eps_delta,             eps_pts) * 0.20
+    )
+
+
+def compute_momentum_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Momentum Score — recent price performance vs absolute thresholds.
+    Returns as decimals (0.10 = +10%).  Negative = penalty, >30% = top.
+    """
+    r1_pts  = [(-0.15, 5),  (-0.05, 25), (0.0, 45), (0.05, 60), (0.10, 75), (0.20, 90), (0.30, 100)]
+    r3_pts  = [(-0.20, 5),  (-0.05, 25), (0.0, 42), (0.08, 58), (0.15, 72), (0.25, 88), (0.40, 100)]
+    r6_pts  = [(-0.25, 5),  (-0.05, 22), (0.0, 38), (0.10, 55), (0.20, 70), (0.35, 87), (0.55, 100)]
+    r12_pts = [(-0.30, 5),  (-0.05, 20), (0.0, 35), (0.12, 52), (0.25, 68), (0.40, 85), (0.65, 100)]
+    return (
+        _score_series(df["ret_1m"],  r1_pts)  * 0.10 +
+        _score_series(df["ret_3m"],  r3_pts)  * 0.25 +
+        _score_series(df["ret_6m"],  r6_pts)  * 0.40 +
+        _score_series(df["ret_12m"], r12_pts) * 0.25
+    )
+
+
+def compute_reverse_momentum_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Reverse Momentum Score — rewards stocks that have fallen the most recently.
+    Inverts the standard momentum scale: large negative returns → high score.
+    Short-term windows weighted more heavily to capture recent drawdowns.
+    -30% in a month → 100;  flat → ~50;  +30% in a month → 3.
+    """
+    r1_pts  = [(-0.30, 100), (-0.20, 88), (-0.10, 75), (-0.05, 62), (0.0, 48), (0.05, 32), (0.10, 18), (0.20, 8),  (0.30, 3)]
+    r3_pts  = [(-0.40, 100), (-0.25, 88), (-0.15, 75), (-0.05, 60), (0.0, 45), (0.08, 30), (0.20, 15), (0.35, 5)]
+    r6_pts  = [(-0.55, 100), (-0.35, 88), (-0.20, 72), (-0.05, 55), (0.0, 42), (0.10, 28), (0.25, 15), (0.40, 5)]
+    r12_pts = [(-0.65, 100), (-0.40, 85), (-0.25, 68), (-0.05, 52), (0.0, 38), (0.12, 22), (0.30, 10), (0.50, 3)]
+    return (
+        _score_series(df["ret_1m"],  r1_pts)  * 0.35 +
+        _score_series(df["ret_3m"],  r3_pts)  * 0.35 +
+        _score_series(df["ret_6m"],  r6_pts)  * 0.20 +
+        _score_series(df["ret_12m"], r12_pts) * 0.10
+    )
+
+
+def compute_quality_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Quality Score — balance-sheet and capital efficiency.
+    ROE: as decimal, >0.20 (20%) is strong; <0 penalised.
+    ROA: >0.10 (10%) excellent.
+    D/E: lower is safer; >2.0 high risk.
+    Current ratio: >2 comfortable; <1 stressed.
+    """
+    roe_pts = [(-0.10, 5), (0.0, 20), (0.05, 40), (0.10, 55), (0.15, 68), (0.20, 80), (0.30, 92), (0.40, 100)]
+    roa_pts = [(-0.05, 5), (0.0, 20), (0.03, 40), (0.06, 55), (0.10, 70), (0.15, 85), (0.20, 100)]
+    de_pts  = [(0.0, 100), (0.25, 90), (0.50, 78), (1.0, 62), (1.5, 48), (2.0, 32), (3.0, 15), (5.0, 5)]
+    cr_pts  = [(0.5, 5),  (0.8, 20),  (1.0, 38),  (1.5, 60), (2.0, 80), (2.5, 90),  (3.0, 100)]
+    return (
+        _score_series(df["roe"],            roe_pts) * 0.35 +
+        _score_series(df["roa"],            roa_pts) * 0.30 +
+        _score_series(df["debt_to_equity"], de_pts)  * 0.20 +
+        _score_series(df["current_ratio"],  cr_pts)  * 0.15
+    )
+
+
+def compute_profitability_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Profitability Score — how much of revenue becomes profit.
+    All margins as decimals.  Negative margins penalised.
+    FCF yield: FCF / market cap.  >5% excellent.
+    """
+    pm_pts  = [(-0.10, 5), (0.0, 18), (0.03, 35), (0.08, 52), (0.15, 68), (0.25, 84), (0.35, 100)]
+    om_pts  = [(-0.10, 5), (0.0, 18), (0.05, 38), (0.12, 55), (0.20, 70), (0.30, 86), (0.40, 100)]
+    fcf_pts = [(-0.05, 5), (0.0, 20), (0.01, 35), (0.03, 50), (0.05, 65), (0.08, 82), (0.12, 100)]
+    return (
+        _score_series(df["profit_margin"],    pm_pts)  * 0.35 +
+        _score_series(df["operating_margin"], om_pts)  * 0.35 +
+        _score_series(df["fcf_yield"],        fcf_pts) * 0.30
+    )
+
+
+def compute_sentiment_score(df: pd.DataFrame) -> pd.Series:
+    """
+    News Sentiment Score — VADER compound score mapped from [-1, +1] to [0, 100].
+    Neutral (0) → 50; strongly positive (+0.5) → 75; strongly negative (-0.5) → 25.
+    """
+    sent_pts = [(-1.0, 0), (-0.5, 25), (-0.2, 38), (0.0, 50), (0.2, 62), (0.5, 75), (1.0, 100)]
+    return _score_series(df["news_sentiment"], sent_pts)
+
+
+def compute_analyst_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Analyst Score — consensus rating + price target upside.
+    analyst_norm: 0=Strong Sell → 1=Strong Buy (absolute mapping to 0–100).
+    analyst_upside: expected % gain (decimal).  >20% = very bullish.
+    analyst_count: more coverage = higher confidence (logarithmic).
+    """
+    norm_pts   = [(0.0, 0), (0.25, 25), (0.50, 50), (0.65, 65), (0.75, 78), (0.875, 90), (1.0, 100)]
+    upside_pts = [(-0.20, 5), (-0.05, 20), (0.0, 35), (0.05, 48), (0.10, 60), (0.20, 78), (0.35, 95), (0.50, 100)]
+    count_pts  = [(0, 0), (1, 20), (3, 40), (5, 55), (10, 70), (20, 85), (30, 100)]
+    return (
+        _score_series(df["analyst_norm"],   norm_pts)   * 0.50 +
+        _score_series(df["analyst_upside"], upside_pts) * 0.35 +
+        _score_series(df["analyst_count"],  count_pts)  * 0.15
+    )
+
+
+def compute_risk_score(df: pd.DataFrame) -> pd.Series:
+    """
+    Risk Score — higher score means LOWER risk (more attractive).
+    Short interest %: >15% very bearish signal; <3% low risk.
+    Volatility 30d (annualised): >60% high risk; <15% stable.
+    Beta deviation from 1.0: extreme values (very high or negative) add tail risk.
+    """
+    short_pts = [(0.0, 100), (0.03, 88), (0.05, 75), (0.10, 55), (0.15, 35), (0.20, 18), (0.30, 5)]
+    vol_pts   = [(0.05, 100), (0.10, 88), (0.15, 78), (0.25, 62), (0.35, 45), (0.50, 25), (0.70, 8), (1.0, 3)]
+    beta_dev  = (df["beta"].fillna(1.0) - 1.0).abs()
+    bdev_pts  = [(0.0, 100), (0.20, 85), (0.40, 70), (0.60, 55), (0.80, 40), (1.0, 25), (1.50, 10), (2.0, 5)]
+    return (
+        _score_series(df["short_percent"],  short_pts) * 0.50 +
+        _score_series(df["volatility_30d"], vol_pts)   * 0.30 +
+        _score_series(beta_dev,             bdev_pts)  * 0.20
+    )
+
+
+def score_stocks(df: pd.DataFrame, weights: dict | None = None) -> pd.DataFrame:
+    df = df.copy()
+    df = df.drop_duplicates(subset=["ticker"], keep="first").reset_index(drop=True)
+
+    # Force every metric column to float before scoring.
+    # yfinance sometimes returns strings ("Infinity", "N/A") for PE/EPS fields
+    # on edge-case securities (REITs, ADRs, CLEFs, foreign listings) — common
+    # in large indices like NYSE.  Without coercion, comparisons like `x > 0`
+    # inside compute_value_score raise TypeError on those rows.
+    _NUMERIC_COLS = [
+        "pe_forward", "pe_trailing", "pb_ratio", "ev_ebitda",
+        "revenue_growth", "earnings_growth", "eps_forward", "eps_trailing",
+        "ret_1m", "ret_3m", "ret_6m", "ret_12m",
+        "roe", "roa", "debt_to_equity", "current_ratio",
+        "profit_margin", "operating_margin", "fcf_yield",
+        "news_sentiment", "analyst_norm", "analyst_upside", "analyst_count",
+        "short_percent", "volatility_30d", "beta", "price", "market_cap",
+    ]
+    for col in _NUMERIC_COLS:
+        if col in df.columns:
+            df[col] = pd.to_numeric(df[col], errors="coerce")
+
+    df["score_value"]             = compute_value_score(df)
+    df["score_growth"]            = compute_growth_score(df)
+    df["score_momentum"]          = compute_momentum_score(df)
+    df["score_reverse_momentum"]  = compute_reverse_momentum_score(df)
+    df["score_quality"]           = compute_quality_score(df)
+    df["score_profitability"]     = compute_profitability_score(df)
+    df["score_sentiment"]         = compute_sentiment_score(df)
+    df["score_analyst"]           = compute_analyst_score(df)
+    df["score_risk"]              = compute_risk_score(df)
+
+    w = weights if weights is not None else WEIGHTS
+    df["composite_score"] = sum(
+        df[f"score_{k}"] * v for k, v in w.items()
+    )
+    return df.sort_values("composite_score", ascending=False).reset_index(drop=True)
+
+
+# ---------------------------------------------------------------------------
+# Display
+# ---------------------------------------------------------------------------
+
+def fmt_pct(val) -> str:
+    if val is None or (isinstance(val, float) and np.isnan(val)):
+        return "N/A"
+    return f"{val*100:.1f}%"
+
+
+def fmt_float(val, decimals=2) -> str:
+    if val is None or (isinstance(val, float) and np.isnan(val)):
+        return "N/A"
+    return f"{val:.{decimals}f}"
+
+
+def fmt_mcap(val) -> str:
+    if val is None or (isinstance(val, float) and np.isnan(val)):
+        return "N/A"
+    if val >= 1e12: return f"${val/1e12:.1f}T"
+    if val >= 1e9:  return f"${val/1e9:.1f}B"
+    if val >= 1e6:  return f"${val/1e6:.1f}M"
+    return f"${val:.0f}"
+
+
+def print_results(df: pd.DataFrame, top_n: int = 50) -> None:
+    top = df.head(top_n).copy()
+    top.index = range(1, len(top) + 1)
+    W = 140
+    print("=" * W)
+    print(f"  TOP {top_n} STOCKS — {datetime.today().strftime('%Y-%m-%d %H:%M')}")
+    print("=" * W)
+    print(
+        f"{'#':>3}  {'Ticker':<7} {'Name':<26} {'Sector':<20} "
+        f"{'Score':>6}  {'Val':>5} {'Grw':>5} {'Mom':>5} {'Qlt':>5} "
+        f"{'Pft':>5} {'Sent':>5} {'Anlst':>6} {'Risk':>5}  "
+        f"{'P/E':>6} {'RevGrw':>7} {'ROE':>6}  {'MktCap':>8}"
+    )
+    print("-" * W)
+    for rank, row in top.iterrows():
+        print(
+            f"{rank:>3}  {row['ticker']:<7} {str(row['name'])[:25]:<26} "
+            f"{str(row['sector'])[:19]:<20} "
+            f"{row['composite_score']:>6.1f}  "
+            f"{row['score_value']:>5.1f} {row['score_growth']:>5.1f} "
+            f"{row['score_momentum']:>5.1f} {row['score_quality']:>5.1f} "
+            f"{row['score_profitability']:>5.1f} {row['score_sentiment']:>5.1f} "
+            f"{row['score_analyst']:>6.1f} {row['score_risk']:>5.1f}  "
+            f"{fmt_float(row.get('pe_forward') or row.get('pe_trailing')):>6} "
+            f"{fmt_pct(row.get('revenue_growth')):>7} "
+            f"{fmt_pct(row.get('roe')):>6}  "
+            f"{fmt_mcap(row.get('market_cap')):>8}"
+        )
+    print("=" * W)
+    w = WEIGHTS
+    print(
+        f"\nFormula: {w['value']*100:.0f}%*Val + {w['growth']*100:.0f}%*Grw + "
+        f"{w['momentum']*100:.0f}%*Mom + {w['quality']*100:.0f}%*Qlt + "
+        f"{w['profitability']*100:.0f}%*Pft + {w['sentiment']*100:.0f}%*Sent + "
+        f"{w['analyst']*100:.0f}%*Anlst + {w['risk']*100:.0f}%*Risk\n"
+    )
+
+
+def save_csv(df: pd.DataFrame, top_n: int) -> str:
+    cols = [
+        "ticker", "name", "sector", "price", "market_cap",
+        "composite_score", "score_value", "score_growth", "score_momentum",
+        "score_quality", "score_profitability", "score_sentiment",
+        "score_analyst", "score_risk",
+        "pe_forward", "pe_trailing", "pb_ratio", "ev_ebitda",
+        "revenue_growth", "earnings_growth",
+        "ret_1m", "ret_3m", "ret_6m", "ret_12m",
+        "roe", "roa", "debt_to_equity", "current_ratio",
+        "profit_margin", "operating_margin", "fcf_yield",
+        "news_sentiment", "analyst_norm", "analyst_upside",
+        "analyst_count", "analyst_target", "recommendation",
+        "short_percent", "beta", "volatility_30d",
+    ]
+    out_cols  = [c for c in cols if c in df.columns]
+    filename  = f"top{top_n}_stocks_{datetime.today().strftime('%Y%m%d')}.csv"
+    df.head(top_n)[out_cols].to_csv(filename, index=False)
+    return filename
+
+
+# ---------------------------------------------------------------------------
+# Entry Point
+# ---------------------------------------------------------------------------
+
+def parse_args():
+    p = argparse.ArgumentParser(description="Multi-factor stock screener")
+    p.add_argument("--top",     type=int, default=50)
+    p.add_argument("--workers", type=int, default=15)
+    p.add_argument("--output",  choices=["console", "csv", "both"], default="console")
+    p.add_argument("--index",   default="All", choices=INDEX_CHOICES,
+                   help="Index universe to screen (default: All)")
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    print("\n" + "=" * 60)
+    print("  MULTI-FACTOR STOCK SCREENER  (8-Factor Analyst Model)")
+    print("=" * 60 + "\n")
+    if _VADER is None:
+        print("  [INFO] vaderSentiment not installed — sentiment scores will be neutral.")
+        print("         Run: pip install vaderSentiment\n")
+
+    tickers = collect_tickers(index=args.index)
+    if not tickers:
+        print("ERROR: Could not retrieve any ticker lists.")
+        sys.exit(1)
+
+    df_raw = fetch_all(tickers, max_workers=args.workers)
+    if df_raw.empty:
+        print("ERROR: No data returned.")
+        sys.exit(1)
+
+    print("Computing scores...")
+    df_scored = score_stocks(df_raw)
+    print(f"Scored {len(df_scored)} stocks.\n")
+
+    if args.output in ("console", "both"):
+        print_results(df_scored, top_n=args.top)
+    if args.output in ("csv", "both"):
+        print(f"Results saved to: {save_csv(df_scored, top_n=args.top)}")
+
+
+# ---------------------------------------------------------------------------
+# Insider Trading — SEC EDGAR Form 4
+# ---------------------------------------------------------------------------
+
+_FORM4_TX_CODES: dict[str, str] = {
+    "P": "Buy",            "S": "Sale",
+    "A": "Award",          "D": "Disposition",
+    "F": "Tax Withholding","G": "Gift",
+    "M": "Option Exercise","X": "Option Exercise",
+    "O": "Option Exercise","J": "Other",
+    "I": "Plan Trade",     "C": "Conversion",
+}
+
+
+def _parse_form4_xml(xml_bytes: bytes, filing_url: str, filed_at: str) -> list[dict]:
+    """Parse a Form 4 XML document and return a list of transaction dicts."""
+    import xml.etree.ElementTree as ET
+    try:
+        root = ET.fromstring(xml_bytes)
+    except ET.ParseError:
+        return []
+
+    def _val(node, *tags):
+        """Return stripped text from the first matching .//tag/value or .//tag."""
+        for tag in tags:
+            n = node.find(f".//{tag}/value")
+            if n is not None and n.text:
+                return n.text.strip()
+            n = node.find(f".//{tag}")
+            if n is not None and n.text:
+                return n.text.strip()
+        return ""
+
+    ticker  = _val(root, "issuerTradingSymbol")
+    company = _val(root, "issuerName")
+    insider = _val(root, "rptOwnerName")
+    period  = _val(root, "periodOfReport")
+
+    title = ""
+    rel = root.find(".//reportingOwnerRelationship")
+    if rel is not None:
+        ot = _val(rel, "officerTitle")
+        if ot:
+            title = ot
+        elif _val(rel, "isDirector") in ("1", "true"):
+            title = "Director"
+        elif _val(rel, "isTenPercentOwner") in ("1", "true"):
+            title = "10% Owner"
+        elif _val(rel, "isOfficer") in ("1", "true"):
+            title = "Officer"
+
+    transactions: list[dict] = []
+    for tx in root.findall(".//nonDerivativeTransaction"):
+        tx_date = _val(tx, "transactionDate") or period
+        tx_code = _val(tx, "transactionCode")
+        tx_type = _FORM4_TX_CODES.get(tx_code, tx_code or "Other")
+
+        try:    shares = float(_val(tx, "transactionShares"))
+        except: shares = None
+        try:    price  = float(_val(tx, "transactionPricePerShare"))
+        except: price  = None
+        try:    owned  = float(_val(tx, "sharesOwnedFollowingTransaction"))
+        except: owned  = None
+
+        value = (shares * price) if (shares and price) else None
+
+        transactions.append({
+            "filed_date":       (filed_at or "")[:10] or tx_date,
+            "tx_date":          tx_date,
+            "ticker":           ticker.upper() if ticker else "—",
+            "company":          company,
+            "insider":          insider,
+            "title":            title,
+            "transaction_type": tx_type,
+            "transaction_code": tx_code,
+            "shares":           shares,
+            "price":            price,
+            "value":            value,
+            "owned_after":      owned,
+            "url":              filing_url,
+        })
+
+    return transactions
+
+
+def fetch_insider_trades(days_back: int = 3, max_results: int = 60,
+                          progress_cb=None) -> list[dict]:
+    """
+    Fetch recent Form 4 insider transactions from SEC EDGAR.
+
+    Uses the EDGAR EFTS search API to list recent filings, then
+    parallel-fetches each Form 4 XML for full transaction details.
+
+    days_back    : number of calendar days back from today to search.
+    max_results  : cap on number of filings fetched (each filing may
+                   contain multiple individual transactions).
+    progress_cb  : optional callable(done_count, total_count).
+
+    Returns a list of transaction dicts sorted by tx_date descending.
+    """
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    from datetime import date, timedelta
+
+    _UA = {"User-Agent": "UltimateInvestmentTool contact@investmenttool.com"}
+
+    end_dt   = date.today()
+    start_dt = end_dt - timedelta(days=max(days_back, 1))
+
+    # ── Step 1: list recent Form 4 filings from EDGAR EFTS ────────────────
+    try:
+        resp = requests.get(
+            "https://efts.sec.gov/LATEST/search-index",
+            params={
+                "forms":     "4",
+                "dateRange": "custom",
+                "startdt":   start_dt.strftime("%Y-%m-%d"),
+                "enddt":     end_dt.strftime("%Y-%m-%d"),
+            },
+            headers=_UA,
+            timeout=12,
+        )
+        resp.raise_for_status()
+        hits = resp.json().get("hits", {}).get("hits", [])[:max_results]
+    except Exception:
+        return []
+
+    if not hits:
+        return []
+
+    # ── Step 2: fetch + parse each Form 4 XML (parallel) ──────────────────
+    def _fetch_one(hit: dict) -> list[dict]:
+        try:
+            src    = hit.get("_source", {})
+            filed  = src.get("file_date", "") or src.get("filed_at", "")
+
+            # Accession number from _source.adsh (not _id which has ":filename" appended)
+            acc_no = src.get("adsh", "")
+            if not acc_no:
+                return []
+
+            # XML filename is embedded in _id as "{adsh}:{filename}"
+            xml_filename = hit["_id"].split(":")[-1]
+
+            # CIK: use ciks[0] from _source — NOT the accession prefix (which is the filing agent)
+            ciks = src.get("ciks", [])
+            if not ciks:
+                return []
+            cik_int = int(ciks[0].lstrip("0") or "0")
+            if cik_int == 0:
+                return []
+
+            acc_nd     = acc_no.replace("-", "")
+            base       = f"https://www.sec.gov/Archives/edgar/data/{cik_int}/{acc_nd}"
+            filing_url = f"{base}/{acc_no}-index.htm"
+
+            xml_url = f"{base}/{xml_filename}"
+            xml_r   = requests.get(xml_url, headers=_UA, timeout=8)
+            xml_r.raise_for_status()
+            return _parse_form4_xml(xml_r.content, filing_url, filed)
+        except Exception:
+            return []
+
+    total   = len(hits)
+    done_n  = 0
+    results: list[dict] = []
+
+    with ThreadPoolExecutor(max_workers=6) as ex:
+        futs = {ex.submit(_fetch_one, h): h for h in hits}
+        for fut in as_completed(futs):
+            done_n += 1
+            results.extend(fut.result() or [])
+            if progress_cb:
+                try:
+                    progress_cb(done_n, total)
+                except Exception:
+                    pass
+
+    results.sort(
+        key=lambda x: (x.get("tx_date") or "", x.get("filed_date") or ""),
+        reverse=True,
+    )
+    return results
+
+
+if __name__ == "__main__":
+    main()
diff --git a/hwid.py b/hwid.py
index 727dfc5..87eabfd 100644
--- a/hwid.py
+++ b/hwid.py
@@ -8,11 +8,13 @@ Generates a stable hardware fingerprint for this machine using:
 Returns a SHA-256 hex digest. Never changes unless hardware changes.
 """
 
+import functools
 import hashlib
 import subprocess
 import winreg
 
 
+@functools.lru_cache(maxsize=None)
 def get_hwid() -> str:
     """Return a stable SHA-256 HWID string for the current machine."""
     components = []
diff --git a/launcher.py b/launcher.py
index 2684b95..f9372ae 100644
--- a/launcher.py
+++ b/launcher.py
@@ -6,57 +6,26 @@ Startup sequence:
   2. Load stored license key — show activation dialog if none found
   3. Verify license against Supabase (with 30-min offline grace period)
   4. Silently check for and apply updates
-  5. Load and run screener_gui.py
-
-Source file hygiene
--------------------
-On every launch, the launcher scans the parent folder of the exe for stray
-copies of screener_gui.py or stock_screener.py and removes them (pulling in
-any newer version first so no edits are lost).
+  5. Launch the bundled screener_gui
 """
 
-import importlib.util
 import os
-import shutil
 import sys
 import tkinter as tk
 from tkinter import messagebox
 
+# Fix SSL certificate path for PyInstaller frozen builds.
+# Without this, requests raises "Could not find a suitable TLS CA certificate bundle".
+if getattr(sys, "frozen", False):
+    import certifi
+    os.environ["REQUESTS_CA_BUNDLE"] = certifi.where()
+    os.environ["SSL_CERT_FILE"]      = certifi.where()
+
 
 # ---------------------------------------------------------------------------
 # Helpers
 # ---------------------------------------------------------------------------
 
-def _exe_dir() -> str:
-    if getattr(sys, "frozen", False):
-        return os.path.dirname(sys.executable)
-    return os.path.dirname(os.path.abspath(__file__))
-
-
-_SOURCE_FILES = ("screener_gui.py", "stock_screener.py")
-
-
-def _sync_source_files(exe_dir: str) -> None:
-    parent_dir = os.path.dirname(exe_dir)
-    if parent_dir == exe_dir:
-        return
-
-    for fname in _SOURCE_FILES:
-        stray = os.path.join(parent_dir, fname)
-        if not os.path.exists(stray):
-            continue
-        live = os.path.join(exe_dir, fname)
-        if not os.path.exists(live) or os.path.getmtime(stray) > os.path.getmtime(live):
-            try:
-                shutil.copy2(stray, live)
-            except OSError:
-                pass
-        try:
-            os.remove(stray)
-        except OSError:
-            pass
-
-
 def _fatal(title: str, message: str) -> None:
     """Show an error dialog and exit."""
     root = tk.Tk()
@@ -71,9 +40,6 @@ def _fatal(title: str, message: str) -> None:
 # ---------------------------------------------------------------------------
 
 def main():
-    exe_dir = _exe_dir()
-    _sync_source_files(exe_dir)
-
     # ------------------------------------------------------------------
     # Step 1: HWID
     # ------------------------------------------------------------------
@@ -82,7 +48,7 @@ def main():
         hwid = get_hwid()
     except Exception as exc:
         _fatal("Ultimate Investment Tool", f"Could not generate hardware ID:\n\n{exc}")
-        return  # unreachable, but satisfies linters
+        return
 
     # ------------------------------------------------------------------
     # Step 2: Load or activate license
@@ -92,12 +58,10 @@ def main():
     license_key = license_check.load_license_key(hwid)
 
     if license_key is None:
-        # First launch — show activation dialog
         import activation_dialog
-        activated = activation_dialog.run_activation()
+        activated = activation_dialog.run_activation(hwid)
         if not activated:
-            sys.exit(0)  # user closed the window
-        # Reload after successful save
+            sys.exit(0)
         license_key = license_check.load_license_key(hwid)
         if license_key is None:
             _fatal("Ultimate Investment Tool", "Activation failed. Please restart and try again.")
@@ -109,7 +73,6 @@ def main():
     valid, reason = license_check.verify_license(license_key, hwid)
 
     if not valid:
-        # License invalid — clear stored key so they can re-enter on next launch
         license_check.delete_license_key()
         _fatal(
             "Ultimate Investment Tool — License Error",
@@ -123,33 +86,20 @@ def main():
     try:
         import updater
         updater.check_and_apply_update()
-        # If an update was applied, updater restarts the process — we never reach here.
     except Exception:
-        pass  # never block the app over a failed update check
+        pass
 
     # ------------------------------------------------------------------
-    # Step 5: Load screener_gui.py
+    # Step 5: Launch bundled app
     # ------------------------------------------------------------------
-    script = os.path.join(exe_dir, "screener_gui.py")
-
-    if os.path.exists(script):
-        if exe_dir not in sys.path:
-            sys.path.insert(0, exe_dir)
-        spec = importlib.util.spec_from_file_location("screener_gui_live", script)
-        mod  = importlib.util.module_from_spec(spec)
-        spec.loader.exec_module(mod)
-        mod.main()
-        return
-
-    # Fallback: frozen version bundled inside the exe
     try:
         import screener_gui
         screener_gui.main()
-    except Exception as exc:
+    except Exception:
+        import traceback
         _fatal(
-            "Ultimate Investment Tool",
-            f"Could not start.\n\n{exc}\n\n"
-            "Make sure screener_gui.py is in the same folder as this exe."
+            "Ultimate Investment Tool — Startup Error",
+            f"The application failed to start:\n\n{traceback.format_exc()}"
         )
 
 
diff --git a/license_check.py b/license_check.py
index 26624b6..199dfea 100644
--- a/license_check.py
+++ b/license_check.py
@@ -4,7 +4,7 @@ License Check
 Validates the stored license key against Supabase on every launch.
 Falls back to a local cache if the server is unreachable (30-minute grace period).
 
-Storage location: %APPDATA%\StockScreener\
+Storage location: %APPDATA%\\StockScreener\\
   license.dat   — XOR-encrypted license key (machine-bound)
   auth_cache.dat — last successful auth result + timestamp
 """
@@ -101,13 +101,21 @@ def delete_license_key() -> None:
 # Auth cache
 # ---------------------------------------------------------------------------
 
-def _save_cache(valid: bool, reason: str) -> None:
+def _save_cache(valid: bool, reason: str, channel: str = "stable") -> None:
     _ensure_dir()
-    payload = {"valid": valid, "reason": reason, "timestamp": time.time()}
+    payload = {"valid": valid, "reason": reason, "channel": channel, "timestamp": time.time()}
     with open(_CACHE_FILE, "w", encoding="utf-8") as f:
         json.dump(payload, f)
 
 
+def get_channel() -> str:
+    """Return the update channel ('stable' or 'beta') from the last auth cache."""
+    cache = _load_cache()
+    if cache:
+        return cache.get("channel", "stable")
+    return "stable"
+
+
 def _load_cache() -> dict | None:
     if not os.path.exists(_CACHE_FILE):
         return None
@@ -142,20 +150,28 @@ def verify_license(license_key: str, hwid: str) -> tuple[bool, str]:
             timeout=10,
         )
         resp.raise_for_status()
-        data   = resp.json()
-        valid  = bool(data.get("valid", False))
-        reason = data.get("reason", "Unknown error")
-        _save_cache(valid, reason)
+        data    = resp.json()
+        valid   = bool(data.get("valid", False))
+        reason  = data.get("reason", "Unknown error")
+        channel = data.get("channel", "stable")
+        _save_cache(valid, reason, channel)
         return valid, reason
 
-    except requests.RequestException:
+    except requests.exceptions.SSLError as e:
+        return False, f"SSL error contacting license server: {e}"
+    except requests.exceptions.ConnectionError as e:
         cache = _load_cache()
         if cache and cache.get("valid"):
             age = time.time() - cache.get("timestamp", 0)
             if age < _GRACE_PERIOD_SECONDS:
                 return True, "offline_grace"
-        return (
-            False,
-            "Cannot reach the license server. "
-            "Please check your internet connection and try again."
-        )
+        return False, f"Cannot connect to license server. Check your internet connection.\n\n({e})"
+    except requests.exceptions.HTTPError as e:
+        return False, f"License server error: {e}"
+    except requests.RequestException as e:
+        cache = _load_cache()
+        if cache and cache.get("valid"):
+            age = time.time() - cache.get("timestamp", 0)
+            if age < _GRACE_PERIOD_SECONDS:
+                return True, "offline_grace"
+        return False, f"License check failed: {e}"
diff --git a/updater.py b/updater.py
index 83308a7..8ffba50 100644
--- a/updater.py
+++ b/updater.py
@@ -1,27 +1,38 @@
 """
 Auto-Updater
 ============
-Checks Supabase for a newer version of screener_gui.py and stock_screener.py.
-If found, silently downloads and replaces the files in the exe directory,
-then restarts the application.
+On every launch (after a successful license check), checks Supabase for a
+newer version. If found:
+  - Downloads new screener_gui.py and stock_screener.py silently
+  - If a new exe is also available, self-replaces via a helper batch script
+    and restarts. The user sees nothing — the app just comes back up updated.
 
 Called after a successful license check on every launch.
 """
 
 import os
+import shutil
+import subprocess
 import sys
 import tempfile
-import shutil
 
 import requests
 
 # ---------------------------------------------------------------------------
-# Current app version — bump this in lockstep with new Supabase version rows
+# Current app version — kept in sync by push_update.py before each build.
 # ---------------------------------------------------------------------------
-APP_VERSION = "1.0.0"
+APP_VERSION = "1.3.1"
 
 # ---------------------------------------------------------------------------
-# Supabase config (same anon key as license_check.py)
+# GitHub token — fine-grained PAT with Contents:read on the release repo.
+# Required to download assets from a private GitHub repository.
+# Generate at: GitHub → Settings → Developer settings → Fine-grained tokens
+# ---------------------------------------------------------------------------
+_GITHUB_TOKEN = "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"
+_GITHUB_REPO  = "nolankovacs/ultimate-investment-tool"
+
+# ---------------------------------------------------------------------------
+# Supabase config
 # ---------------------------------------------------------------------------
 _SUPABASE_URL  = "https://yeispcpmepjelfbhfkwr.supabase.co"
 _SUPABASE_ANON = (
@@ -36,9 +47,6 @@ _HEADERS = {
     "Content-Type": "application/json",
 }
 
-# Files that can be updated without rebuilding the exe
-_UPDATABLE_FILES = ("screener_gui.py", "stock_screener.py")
-
 
 def _exe_dir() -> str:
     if getattr(sys, "frozen", False):
@@ -47,7 +55,6 @@ def _exe_dir() -> str:
 
 
 def _parse_version(v: str) -> tuple:
-    """Convert '1.2.3' → (1, 2, 3) for comparison."""
     try:
         return tuple(int(x) for x in v.strip().split("."))
     except Exception:
@@ -55,11 +62,18 @@ def _parse_version(v: str) -> tuple:
 
 
 def _download_file(url: str, dest_path: str) -> None:
-    """Download url → dest_path, using a temp file so the write is atomic."""
+    """Download url → dest_path atomically via a temp file."""
+    dl_headers = {}
+    if _GITHUB_TOKEN and "github.com" in url:
+        dl_headers["Authorization"] = f"Bearer {_GITHUB_TOKEN}"
+        # GitHub API asset endpoint requires this header to stream the binary
+        if "api.github.com" in url and "/releases/assets/" in url:
+            dl_headers["Accept"] = "application/octet-stream"
+
     tmp_dir  = tempfile.mkdtemp()
     tmp_path = os.path.join(tmp_dir, os.path.basename(dest_path))
     try:
-        with requests.get(url, stream=True, timeout=30) as r:
+        with requests.get(url, stream=True, timeout=60, headers=dl_headers) as r:
             r.raise_for_status()
             with open(tmp_path, "wb") as f:
                 for chunk in r.iter_content(chunk_size=65536):
@@ -69,53 +83,173 @@ def _download_file(url: str, dest_path: str) -> None:
         shutil.rmtree(tmp_dir, ignore_errors=True)
 
 
-def _restart() -> None:
-    """Restart the current process cleanly."""
-    if getattr(sys, "frozen", False):
-        os.execv(sys.executable, [sys.executable] + sys.argv[1:])
-    else:
-        os.execv(sys.executable, [sys.executable] + sys.argv)
+def _self_replace_exe(exe_url: str) -> None:
+    """
+    Download the new exe to %TEMP%, then launch a helper batch script that
+    waits for this process to exit, moves the file into place, and restarts
+    the app.  Nothing is left in the application directory.  Never returns.
+    """
+    if not getattr(sys, "frozen", False):
+        return  # only meaningful in a frozen exe
+
+    current_exe = os.path.abspath(sys.executable)
+    tmp_dir     = tempfile.gettempdir()
+    pending_exe = os.path.join(tmp_dir, "StockScreener_pending.exe")
+
+    # Download to %TEMP% — nothing lands next to the running exe
+    try:
+        _download_file(exe_url, pending_exe)
+    except Exception as exc:
+        _log_update_error(f"_download_file failed for {exe_url}: {exc}")
+        return
+
+    # Batch script in %TEMP% — deletes itself and the pending file when done
+    helper = os.path.join(tmp_dir, "uit_update.bat")
+    with open(helper, "w") as f:
+        f.write(
+            f"@echo off\n"
+            f":retry\n"
+            f"timeout /t 1 /nobreak >nul\n"
+            f"move /Y \"{pending_exe}\" \"{current_exe}\"\n"
+            f"if errorlevel 1 goto retry\n"
+            f"start \"\" \"{current_exe}\"\n"
+            f"del \"%~f0\"\n"
+        )
+
+    # Launch the helper detached, then exit so the running exe is unlocked
+    subprocess.Popen(
+        ["cmd", "/c", helper],
+        creationflags=subprocess.CREATE_NO_WINDOW | subprocess.DETACHED_PROCESS,
+        close_fds=True,
+    )
+    sys.exit(0)
+
+
+def get_release_notes() -> tuple:
+    """
+    Returns (version, release_notes) for the current channel from Supabase.
+    Falls back gracefully on any error.
+    """
+    try:
+        import license_check
+        channel = license_check.get_channel()
+        resp = requests.post(
+            f"{_SUPABASE_URL}/rest/v1/rpc/get_latest_version",
+            headers=_HEADERS,
+            json={"p_channel": channel},
+            timeout=8,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        version = data.get("version", APP_VERSION)
+        notes = data.get("release_notes") or "No release notes available."
+        return version, notes
+    except Exception:
+        return APP_VERSION, "Unable to fetch release notes."
+
+
+def _log_update_error(msg: str) -> None:
+    """Upload update events/errors to Supabase update_logs table."""
+    # Remote upload only — no local file created
+    try:
+        hwid = "unknown"
+        channel = "unknown"
+        try:
+            from hwid import get_hwid
+            hwid = get_hwid()
+        except Exception:
+            pass
+        try:
+            import license_check
+            channel = license_check.get_channel()
+        except Exception:
+            pass
+
+        requests.post(
+            f"{_SUPABASE_URL}/rest/v1/update_logs",
+            headers={
+                **_HEADERS,
+                "Content-Type": "application/json",
+                "Prefer":       "return=minimal",
+            },
+            json={
+                "hwid":        hwid,
+                "app_version": APP_VERSION,
+                "channel":     channel,
+                "message":     msg,
+            },
+            timeout=5,
+        )
+    except Exception:
+        pass  # never let logging break the app
+
+
+def _get_github_exe_url(version: str, channel: str) -> str | None:
+    """
+    Query the GitHub Releases API to find the StockScreener.exe asset URL
+    for the given version and channel. Used as a fallback when Supabase
+    doesn't return exe_url.
+    """
+    try:
+        tag = f"v{version}-{channel}" if channel != "stable" else f"v{version}"
+        resp = requests.get(
+            f"https://api.github.com/repos/{_GITHUB_REPO}/releases/tags/{tag}",
+            headers={
+                "Authorization": f"Bearer {_GITHUB_TOKEN}",
+                "Accept":        "application/vnd.github+json",
+            },
+            timeout=10,
+        )
+        resp.raise_for_status()
+        for asset in resp.json().get("assets", []):
+            if asset["name"] == "StockScreener.exe":
+                return asset["url"]   # API asset URL — requires octet-stream header
+        _log_update_error(f"GitHub release {tag} found but no StockScreener.exe asset")
+        return None
+    except Exception as exc:
+        _log_update_error(f"_get_github_exe_url({version}, {channel}) failed: {exc}")
+        return None
 
 
 def check_and_apply_update() -> None:
     """
-    Silently check for updates and apply them if available.
-    Errors are swallowed — a failed update check never blocks the app.
+    Silently check for updates and apply them. Errors are swallowed so a
+    failed update check never blocks the app from launching.
     """
     try:
+        import license_check
+        channel = license_check.get_channel()
+
+        # Use the RPC — it runs with elevated DB permissions (SECURITY DEFINER)
+        # so the anon key can read the table through it even with RLS enabled.
         resp = requests.post(
             f"{_SUPABASE_URL}/rest/v1/rpc/get_latest_version",
             headers=_HEADERS,
-            json={},
+            json={"p_channel": channel},
             timeout=8,
         )
         resp.raise_for_status()
         data = resp.json()
 
-        latest  = data.get("version", APP_VERSION)
-        gui_url = data.get("gui_py_url")
-        scr_url = data.get("screener_py_url")
+        latest = data.get("version", APP_VERSION)
 
         if _parse_version(latest) <= _parse_version(APP_VERSION):
             return  # already up to date
 
-        exe_dir  = _exe_dir()
-        updated  = False
+        # Always resolve the download URL via the GitHub API — direct
+        # github.com/releases/download URLs return 404 for private repos
+        # when accessed with a token outside of a browser session.
+        exe_url = _get_github_exe_url(latest, channel)
+        if not exe_url:
+            _log_update_error(
+                f"Update available ({APP_VERSION} → {latest}) but could not "
+                f"locate the asset on GitHub for channel={channel}"
+            )
+            return
 
-        if gui_url:
-            dest = os.path.join(exe_dir, "screener_gui.py")
-            _download_file(gui_url, dest)
-            updated = True
+        # Self-replace exe if a new one is available (exits this process)
+        _self_replace_exe(exe_url)
 
-        if scr_url:
-            dest = os.path.join(exe_dir, "stock_screener.py")
-            _download_file(scr_url, dest)
-            updated = True
-
-        if updated:
-            # Restart so the fresh .py files are loaded
-            _restart()
-
-    except Exception:
-        # Never crash the app over a failed update check
-        pass
+    except Exception as exc:
+        _log_update_error(f"check_and_apply_update failed: {exc}")
+        # never crash the app over a failed update check