From bac9eff6f63ecb11d05cf8484dc95e6e4c800672 Mon Sep 17 00:00:00 2001
From: vanshshah10002-prog <vanshshah10002@gmail.com>
Date: Wed, 25 Feb 2026 05:00:18 +0530
Subject: [PATCH] =?UTF-8?q?Initial=20commit:=20FinanceIQ=20v5.2=20?=
 =?UTF-8?q?=E2=80=94=20full-stack=20financial=20analytics=20platform?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 .env.example                      |   21 +
 .gitignore                        |   44 +
 01_basic_stock_data.py            |   74 +
 02_ratios_and_models.py           |   77 +
 03_technicals_risk_performance.py |   70 +
 04_economics_and_export.py        |   69 +
 README.md                         |  150 ++
 advisor.py                        |  106 ++
 app.py                            | 1672 ++++++++++++++++++++++
 backtester.py                     |  177 +++
 news_analyzer.py                  |  101 ++
 options_engine.py                 |  185 +++
 portfolio_engine.py               |  741 ++++++++++
 requirements.txt                  |    7 +
 static/script.js                  | 1649 +++++++++++++++++++++
 static/style.css                  | 2212 +++++++++++++++++++++++++++++
 technical_analyzer.py             |  205 +++
 templates/index.html              |  890 ++++++++++++
 test_intraday.py                  |   19 +
 test_news.py                      |   27 +
 20 files changed, 8496 insertions(+)
 create mode 100644 .env.example
 create mode 100644 .gitignore
 create mode 100644 01_basic_stock_data.py
 create mode 100644 02_ratios_and_models.py
 create mode 100644 03_technicals_risk_performance.py
 create mode 100644 04_economics_and_export.py
 create mode 100644 README.md
 create mode 100644 advisor.py
 create mode 100644 app.py
 create mode 100644 backtester.py
 create mode 100644 news_analyzer.py
 create mode 100644 options_engine.py
 create mode 100644 portfolio_engine.py
 create mode 100644 requirements.txt
 create mode 100644 static/script.js
 create mode 100644 static/style.css
 create mode 100644 technical_analyzer.py
 create mode 100644 templates/index.html
 create mode 100644 test_intraday.py
 create mode 100644 test_news.py

diff --git a/.env.example b/.env.example
new file mode 100644
index 0000000..977e007
--- /dev/null
+++ b/.env.example
@@ -0,0 +1,21 @@
+# FinanceIQ v5 — Environment Variables
+# Copy this to .env and fill in your API keys
+
+# Financial Modeling Prep (required for historical data & ratios)
+FMP_API_KEY=your_fmp_api_key_here
+
+# Finnhub (required for analyst ratings, insider trading)
+FINNHUB_API_KEY=your_finnhub_api_key_here
+
+# FRED (required for macroeconomic indicators)
+FRED_API_KEY=your_fred_api_key_here
+
+# Alpha Vantage (required for sector heatmap, currency conversion)
+ALPHA_VANTAGE_KEY=your_alpha_vantage_key_here
+
+# Ollama (optional — local AI model, defaults to http://localhost:11434)
+OLLAMA_URL=http://localhost:11434
+
+# Zerodha Kite Connect (optional — for portfolio management)
+# KITE_API_KEY=your_kite_api_key_here
+# KITE_API_SECRET=your_kite_api_secret_here
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..832cb59
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*.pyo
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual Environment
+venv/
+.venv/
+env/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+.gemini/
+
+# Environment Variables & Secrets
+.env
+
+# OS
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Logs
+*.log
+
+# Database (local state)
+portfolio.db
+portfolio.db-wal
+portfolio.db-shm
+
+# Data exports
+*.xlsx
+*.csv
+!sample_data/
+
+# Assignment PDFs
+*.pdf
diff --git a/01_basic_stock_data.py b/01_basic_stock_data.py
new file mode 100644
index 0000000..283d290
--- /dev/null
+++ b/01_basic_stock_data.py
@@ -0,0 +1,74 @@
+"""
+=== FinanceToolkit - Lesson 1: Getting Basic Stock Data ===
+
+This script shows you how to:
+  1. Initialize the Toolkit with one or more stock tickers
+  2. Fetch historical price data (OHLC, volume, returns)
+  3. Fetch financial statements (income, balance sheet, cash flow)
+
+Run this file:  python 01_basic_stock_data.py
+"""
+
+from financetoolkit import Toolkit
+
+# ── 1. Setup ──────────────────────────────────────────────────────────
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+
+# You can pass one ticker or a list of tickers.
+# start_date limits how far back data goes.
+companies = Toolkit(
+    tickers=["AAPL", "MSFT"],
+    api_key=API_KEY,
+    start_date="2020-01-01",   # data from Jan 2020 onwards
+)
+
+# ── 2. Historical Price Data ─────────────────────────────────────────
+print("=" * 60)
+print("HISTORICAL PRICE DATA (first 10 rows)")
+print("=" * 60)
+
+historical = companies.get_historical_data()
+print(historical.head(10))
+print()
+
+# Filter to just one stock using .xs()
+print("--- Apple only ---")
+apple_hist = historical.xs("AAPL", level=1, axis=1)
+print(apple_hist.head(10))
+print()
+
+# ── 3. Income Statement ─────────────────────────────────────────────
+print("=" * 60)
+print("INCOME STATEMENT (Annual)")
+print("=" * 60)
+
+income = companies.get_income_statement()
+print(income.head(10))
+print()
+
+# Filter to just Apple
+print("--- Apple Income Statement ---")
+apple_income = income.loc["AAPL"]
+print(apple_income.head(10))
+print()
+
+# ── 4. Balance Sheet ─────────────────────────────────────────────────
+print("=" * 60)
+print("BALANCE SHEET STATEMENT (Annual)")
+print("=" * 60)
+
+balance = companies.get_balance_sheet_statement()
+print(balance.head(10))
+print()
+
+# ── 5. Cash Flow Statement ───────────────────────────────────────────
+print("=" * 60)
+print("CASH FLOW STATEMENT (Annual)")
+print("=" * 60)
+
+cashflow = companies.get_cash_flow_statement()
+print(cashflow.head(10))
+print()
+
+print("[DONE] You've just pulled real stock data for AAPL & MSFT.")
+print("   Try changing the tickers list or start_date above and re-run!")
diff --git a/02_ratios_and_models.py b/02_ratios_and_models.py
new file mode 100644
index 0000000..018a521
--- /dev/null
+++ b/02_ratios_and_models.py
@@ -0,0 +1,77 @@
+"""
+=== FinanceToolkit - Lesson 2: Financial Ratios & Models ===
+
+This script shows you how to:
+  1. Calculate profitability, liquidity, and valuation ratios
+  2. Run financial models (DuPont Analysis, WACC, etc.)
+
+Run this file:  python 02_ratios_and_models.py
+"""
+
+from financetoolkit import Toolkit
+
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+
+companies = Toolkit(
+    tickers=["AAPL", "MSFT", "GOOGL"],
+    api_key=API_KEY,
+    start_date="2020-01-01",
+)
+
+# ── 1. Profitability Ratios ──────────────────────────────────────────
+print("=" * 60)
+print("PROFITABILITY RATIOS")
+print("=" * 60)
+
+profitability = companies.ratios.collect_profitability_ratios()
+print(profitability)
+print()
+
+# ── 2. Liquidity Ratios ──────────────────────────────────────────────
+print("=" * 60)
+print("LIQUIDITY RATIOS")
+print("=" * 60)
+
+liquidity = companies.ratios.collect_liquidity_ratios()
+print(liquidity)
+print()
+
+# ── 3. Valuation Ratios ──────────────────────────────────────────────
+print("=" * 60)
+print("VALUATION RATIOS (e.g. P/E, P/B, EV/EBITDA)")
+print("=" * 60)
+
+valuation = companies.ratios.collect_valuation_ratios()
+print(valuation)
+print()
+
+# ── 4. Individual Ratio ──────────────────────────────────────────────
+# Use get_ functions for a single ratio
+print("=" * 60)
+print("RETURN ON EQUITY (single ratio)")
+print("=" * 60)
+
+roe = companies.ratios.get_return_on_equity()
+print(roe)
+print()
+
+# ── 5. DuPont Analysis ───────────────────────────────────────────────
+print("=" * 60)
+print("EXTENDED DUPONT ANALYSIS")
+print("=" * 60)
+
+dupont = companies.models.get_extended_dupont_analysis()
+print(dupont)
+print()
+
+# ── 6. Weighted Average Cost of Capital (WACC) ───────────────────────
+print("=" * 60)
+print("WEIGHTED AVERAGE COST OF CAPITAL (WACC)")
+print("=" * 60)
+
+wacc = companies.models.get_weighted_average_cost_of_capital()
+print(wacc)
+print()
+
+print("[DONE] You now know how to compute 50+ financial ratios")
+print("   and run valuation models on any public company.")
diff --git a/03_technicals_risk_performance.py b/03_technicals_risk_performance.py
new file mode 100644
index 0000000..8e1bb85
--- /dev/null
+++ b/03_technicals_risk_performance.py
@@ -0,0 +1,70 @@
+"""
+=== FinanceToolkit - Lesson 3: Technical Indicators, Risk & Performance ===
+
+This script shows you how to:
+  1. Get technical indicators (Bollinger Bands, MACD, RSI, Ichimoku)
+  2. Measure risk (Value at Risk)
+  3. Evaluate performance (Fama-French factor correlations)
+
+Run this file:  python 03_technicals_risk_performance.py
+"""
+
+from financetoolkit import Toolkit
+
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+
+companies = Toolkit(
+    tickers=["AAPL", "MSFT"],
+    api_key=API_KEY,
+    start_date="2020-01-01",
+)
+
+# ── 1. Bollinger Bands ───────────────────────────────────────────────
+print("=" * 60)
+print("BOLLINGER BANDS")
+print("=" * 60)
+
+bollinger = companies.technicals.get_bollinger_bands()
+print(bollinger.head(15))
+print()
+
+# ── 2. MACD ───────────────────────────────────────────────────────────
+print("=" * 60)
+print("MACD (Moving Average Convergence Divergence)")
+print("=" * 60)
+
+macd = companies.technicals.get_moving_average_convergence_divergence()
+print(macd.head(15))
+print()
+
+# ── 3. RSI ────────────────────────────────────────────────────────────
+print("=" * 60)
+print("RSI (Relative Strength Index)")
+print("=" * 60)
+
+rsi = companies.technicals.get_relative_strength_index()
+print(rsi.head(15))
+print()
+
+# ── 4. Value at Risk ─────────────────────────────────────────────────
+print("=" * 60)
+print("VALUE AT RISK (Weekly)")
+print("=" * 60)
+
+var = companies.risk.get_value_at_risk(period="weekly")
+print(var.head(15))
+print()
+
+# ── 5. Factor Correlations ───────────────────────────────────────────
+print("=" * 60)
+print("FAMA-FRENCH FACTOR CORRELATIONS (Quarterly)")
+print("=" * 60)
+
+correlations = companies.performance.get_factor_asset_correlations(
+    period="quarterly"
+)
+print(correlations)
+print()
+
+print("[DONE] You can now analyze stocks with technical indicators,")
+print("   assess risk with VaR, and see performance factor exposures.")
diff --git a/04_economics_and_export.py b/04_economics_and_export.py
new file mode 100644
index 0000000..0384c3a
--- /dev/null
+++ b/04_economics_and_export.py
@@ -0,0 +1,69 @@
+"""
+=== FinanceToolkit - Lesson 4: Economics Data & Exporting Results ===
+
+This script shows you how to:
+  1. Access macroeconomic data (GDP, CPI, unemployment)
+  2. Export any DataFrame to CSV or Excel for further use
+
+Run this file:  python 04_economics_and_export.py
+"""
+
+from financetoolkit import Toolkit
+
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+
+companies = Toolkit(
+    tickers=["AAPL"],
+    api_key=API_KEY,
+    start_date="2020-01-01",
+)
+
+# ── 1. Unemployment Rates ─────────────────────────────────────────────
+print("=" * 60)
+print("UNEMPLOYMENT RATES")
+print("=" * 60)
+
+unemployment = companies.economics.get_unemployment_rate()
+print(unemployment.head(10))
+print()
+
+# ── 2. Consumer Price Index (CPI) ────────────────────────────────────
+print("=" * 60)
+print("CONSUMER PRICE INDEX (CPI)")
+print("=" * 60)
+
+cpi = companies.economics.get_consumer_price_index()
+print(cpi.head(10))
+print()
+
+# ── 3. GDP ────────────────────────────────────────────────────────────
+print("=" * 60)
+print("GROSS DOMESTIC PRODUCT (GDP)")
+print("=" * 60)
+
+gdp = companies.economics.get_gross_domestic_product()
+print(gdp.head(10))
+print()
+
+# ── 4. Exporting Data ────────────────────────────────────────────────
+# Any DataFrame can be saved to CSV or Excel for use in reports,
+# other tools, or further analysis.
+
+# Export historical data to CSV
+historical = companies.get_historical_data()
+historical.to_csv("aapl_historical_data.csv")
+print("[SAVED] aapl_historical_data.csv")
+
+# Export income statement to Excel
+income = companies.get_income_statement()
+income.to_excel("aapl_income_statement.xlsx")
+print("[SAVED] aapl_income_statement.xlsx")
+
+# Export ratios to CSV
+ratios = companies.ratios.collect_profitability_ratios()
+ratios.to_csv("aapl_profitability_ratios.csv")
+print("[SAVED] aapl_profitability_ratios.csv")
+
+print()
+print("[DONE] Your data has been exported. Open the CSV/Excel files")
+print("   in Excel, Google Sheets, or any data analysis tool.")
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..f0e0157
--- /dev/null
+++ b/README.md
@@ -0,0 +1,150 @@
+<p align="center">
+  <h1 align="center">📊 FinanceIQ</h1>
+  <p align="center">
+    <strong>Real-time Financial Analytics & Portfolio Simulation Platform</strong>
+  </p>
+  <p align="center">
+    <img src="https://img.shields.io/badge/python-3.10+-blue?style=flat-square&logo=python" alt="Python">
+    <img src="https://img.shields.io/badge/flask-3.x-green?style=flat-square&logo=flask" alt="Flask">
+    <img src="https://img.shields.io/badge/version-5.2-purple?style=flat-square" alt="Version">
+    <img src="https://img.shields.io/badge/license-MIT-yellow?style=flat-square" alt="License">
+  </p>
+</p>
+
+---
+
+A full-stack financial analytics web application built with **Flask**, **yfinance**, and **Google Gemini AI**. Features interactive charting, professional-grade portfolio simulation, options pricing, backtesting, AI-driven advisory, and a live market dashboard — all in a sleek, responsive single-page dashboard.
+
+## ✨ Features
+
+### 📈 Market Analysis
+- **Interactive Candlestick Charts** — powered by TradingView Lightweight Charts
+- **Technical Indicators** — RSI, MACD, Bollinger Bands, SMA/EMA, ATR, Stochastic
+- **Candlestick Pattern Recognition** — Doji, Hammer, Engulfing, Morning Star, and more
+- **Key Financial Metrics** — P/E, ROE, D/E, Quick Ratio, Dividend Yield
+- **Sector Peer Comparison** — heatmap of competitors across 7 sectors
+- **Valuation Models** — DCF, Graham Number, PEG Ratio, DDM
+
+### 💼 Portfolio Simulation
+- **$100K Paper Trading** — buy/sell with real-time prices from Yahoo Finance
+- **Advanced Order Types** — Market, Limit, and Stop orders
+- **Short Selling** — open and cover short positions with margin tracking
+- **Slippage & Commission Modeling** — realistic IBKR-style execution costs
+- **Equity Curve** — track portfolio value over time with interactive charts
+- **Performance Analytics** — Sharpe, Sortino, Calmar ratios, profit factor, max drawdown
+
+### 🎯 Options Pricing
+- **Black-Scholes Model** — call/put pricing with real-time IV
+- **Greeks Dashboard** — Delta, Gamma, Theta, Vega, Rho
+- **Monte Carlo Simulation** — 10,000-path price projections
+- **Interactive Payoff Charts** — visualize P&L at expiration
+
+### 🤖 AI-Powered Advisory
+- **Gemini AI Integration** — personalized investment analysis
+- **Macro Dashboard** — Fed rates, Treasury yields, VIX, DXY, oil, gold
+- **Risk Assessment** — automated risk scoring with traffic-light indicators
+- **Natural Language Insights** — ask questions about any stock
+
+### 📰 News & Sentiment
+- **Real-time News Feed** — latest headlines for any ticker
+- **AI Sentiment Analysis** — bullish/bearish/neutral classification
+- **Currency Converter** — 150+ currency pairs with live rates
+
+### 🔬 Backtesting Engine
+- **Strategy Backtester** — SMA crossover, RSI, MACD, Bollinger Band strategies
+- **Bi-directional Trading** — long and short strategy support
+- **Performance Metrics** — Sharpe ratio, win rate, max drawdown, trade log
+
+### 🌍 Market Dashboard
+- **Global Indices** — S&P 500, NASDAQ, Dow, FTSE, Nikkei, DAX
+- **Commodities** — Gold, Silver, Crude Oil, Natural Gas
+- **Currency Pairs** — EUR/USD, GBP/USD, USD/JPY, and more
+- **Live Pulse** — auto-refreshing with animated counters
+
+## 🚀 Quick Start
+
+### Prerequisites
+- Python 3.10+
+- Google Gemini API key ([Get one here](https://makersuite.google.com/app/apikey))
+
+### Installation
+
+```bash
+# Clone the repo
+git clone https://github.com/YOUR_USERNAME/FinanceIQ.git
+cd FinanceIQ
+
+# Install dependencies
+pip install -r requirements.txt
+
+# Set up environment variables
+cp .env.example .env
+# Edit .env and add your GEMINI_API_KEY
+
+# Run the application
+python app.py
+```
+
+Then open `http://localhost:5000` in your browser.
+
+## 📁 Project Structure
+
+```
+FinanceIQ/
+├── app.py                  # Flask server & API routes
+├── portfolio_engine.py     # Portfolio simulation engine (SQLite-backed)
+├── options_engine.py       # Black-Scholes, Greeks, Monte Carlo
+├── backtester.py           # Strategy backtesting engine
+├── advisor.py              # Gemini AI financial advisory
+├── technical_analyzer.py   # Technical indicators & patterns
+├── news_analyzer.py        # News fetching & sentiment analysis
+├── requirements.txt        # Python dependencies
+├── .env.example            # Environment variable template
+├── templates/
+│   └── index.html          # Single-page dashboard UI
+└── static/
+    ├── script.js           # Frontend logic & chart rendering
+    └── style.css           # Glassmorphism UI design system
+```
+
+## 🛠️ Tech Stack
+
+| Layer | Technology |
+|-------|-----------|
+| **Backend** | Flask, Python 3.10+ |
+| **Data** | yfinance, Yahoo Finance API |
+| **AI** | Google Gemini 2.0 Flash |
+| **Database** | SQLite (WAL mode) |
+| **Charts** | TradingView Lightweight Charts |
+| **Frontend** | Vanilla JS, CSS (Glassmorphism) |
+
+## 📊 API Endpoints
+
+| Endpoint | Method | Description |
+|----------|--------|-------------|
+| `/api/analyze` | POST | Full stock analysis |
+| `/api/suggest` | GET | Ticker autocomplete |
+| `/api/portfolio` | GET | Portfolio summary |
+| `/api/portfolio/buy` | POST | Buy long |
+| `/api/portfolio/sell` | POST | Sell long |
+| `/api/portfolio/short` | POST | Short sell |
+| `/api/portfolio/cover` | POST | Cover short |
+| `/api/portfolio/limit-order` | POST | Place limit order |
+| `/api/portfolio/stop-order` | POST | Place stop order |
+| `/api/portfolio/analytics` | GET | Performance metrics |
+| `/api/portfolio/equity-curve` | GET | Equity curve data |
+| `/api/market-summary` | GET | Market dashboard data |
+| `/api/options/price` | POST | Options pricing |
+| `/api/backtest` | POST | Run backtests |
+| `/api/advisor/analyze` | POST | AI advisory |
+| `/api/news` | GET | News & sentiment |
+
+## 📜 License
+
+This project is for educational purposes. Built as part of a university finance course.
+
+---
+
+<p align="center">
+  Built with ❤️ using Flask & yfinance
+</p>
diff --git a/advisor.py b/advisor.py
new file mode 100644
index 0000000..8fa5041
--- /dev/null
+++ b/advisor.py
@@ -0,0 +1,106 @@
+"""
+Financial Advisory Algorithm - Phase 7 (Bi-Directional / Market Neutral)
+Analyzes Technicals + News to suggest Long, Short, or Hedge positions.
+"""
+import technical_analyzer
+import news_analyzer
+import sys
+
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+
+def get_user_input():
+    print("\n=== Financial Advisor (Bi-Directional Hedge Edition) ===")
+    ticker = input("Enter Stock Ticker (e.g., ^NSEBANK, NVDA): ").strip().upper()
+    if not ticker: ticker = "^NSEBANK"
+    try:
+        budget = float(input("Enter Monthly Budget (in USD/GBP): ").strip())
+    except ValueError: budget = 150.0
+    return ticker, budget
+
+def determine_strategy(tech, sent):
+    """
+    Combines news sentiment and technicals to pick direction.
+    """
+    price = tech['price']
+    ema5 = tech.get('ema_5', price)
+    bb_upper = tech.get('bb_upper', 0)
+    bb_lower = tech.get('bb_lower', 0)
+    bb_width = (bb_upper - bb_lower) / price if price > 0 else 0
+    
+    sentiment_score = sent['average_score']
+    
+    analysis = []
+    
+    # DIRECTIONAL BIAS
+    technical_bias = "BULLISH" if price > ema5 else "BEARISH"
+    sentiment_bias = "BULLISH" if sentiment_score > 0.1 else "BEARISH" if sentiment_score < -0.1 else "NEUTRAL"
+    
+    analysis.append(f"Technical Bias (EMA 5): {technical_bias}")
+    analysis.append(f"Sentiment Bias (News): {sentiment_bias} ({sentiment_score})")
+
+    # DECISION LOGIC
+    if bb_width > 0.08:
+        # High volatility = Hedge
+        signal = "HEDGE (50% Long / 50% Short)"
+        reason = "Market volatility is extremely high (BB Width > 8%). Hedging will neutralize risk from weekend news gaps."
+    elif technical_bias == "BULLISH" and sentiment_bias != "BEARISH":
+        signal = "AGGRESSIVE LONG"
+        reason = "Price is trending above EMA 5 and news sentiment confirms strength."
+    elif technical_bias == "BEARISH" and sentiment_bias != "BULLISH":
+        signal = "AGGRESSIVE SHORT"
+        reason = "Price is breaking down and news sentiment is negative. Profit from the drop."
+    else:
+        # Conflict between news and tech
+        signal = "TACTICAL HEDGE / WAIT"
+        reason = "Conflicting signals (Tech vs Sentiment). Protecting capital is a priority."
+        
+    return {
+        'signal': signal,
+        'reason': reason,
+        'details': analysis,
+        'sentiment_data': sent
+    }
+
+def print_trade_plan(ticker, budget, tech, strategy):
+    print(f"\n--- {ticker} BI-DIRECTIONAL PLAN ---")
+    for detail in strategy['details']:
+        print(f" * {detail}")
+    
+    print(f"\n RECOMMENDED ACTION: {strategy['signal']}")
+    print(f" RATIONALE: {strategy['reason']}")
+    
+    price = tech['price']
+    if "LONG" in strategy['signal']:
+        print(f"\n [BULLISH EXECUTION]")
+        print(f"  - Entry:    {price:.2f}")
+        print(f"  - Target:   {price * 1.05:.2f} (+5%)")
+        print(f"  - Stop:     {price * 0.97:.2f} (-3%)")
+    elif "SHORT" in strategy['signal']:
+        print(f"\n [BEARISH EXECUTION]")
+        print(f"  - Entry:    {price:.2f} (Sell)")
+        print(f"  - Target:   {price * 0.95:.2f} (Profit from drop)")
+        print(f"  - Stop:     {price * 1.03:.2f} (Exit if price rises)")
+    elif "HEDGE" in strategy['signal']:
+        print(f"\n [NEUTRAL EXECUTION]")
+        print(f"  - Long Px:  {price:.2f} (50% Allocation)")
+        print(f"  - Short Px: {price:.2f} (50% Allocation)")
+        print(f"  - Effect:   Portfolio value stays stable regardless of Monday open.")
+
+def main():
+    ticker, budget = get_user_input()
+    
+    print(f"\n... Analyzing {ticker} (Technicals + News) ...")
+    tech_data = technical_analyzer.get_technicals(ticker, API_KEY)
+    
+    # Fetch real news
+    news_items = news_analyzer.fetch_news(ticker, limit=5)
+    sentiment = news_analyzer.analyze_sentiment(news_items)
+    
+    if tech_data:
+        strategy = determine_strategy(tech_data, sentiment)
+        print_trade_plan(ticker, budget, tech_data, strategy)
+    else:
+        print("Failed to fetch data.")
+
+if __name__ == "__main__":
+    main()
diff --git a/app.py b/app.py
new file mode 100644
index 0000000..403d205
--- /dev/null
+++ b/app.py
@@ -0,0 +1,1672 @@
+"""
+Financial Analysis Web App — Backend (Flask) v3
+Features: Interactive chart overlays, always-fetch financials, indicator tooltips, competitor analysis
+"""
+from flask import Flask, render_template, request, jsonify, send_file, Response
+from financetoolkit import Toolkit
+import requests as http_requests  # for Ollama + external API calls
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+import feedparser
+import pandas as pd
+import numpy as np
+import openpyxl
+from io import BytesIO
+from datetime import datetime, timedelta
+from difflib import SequenceMatcher
+import json, traceback, time, math
+
+app = Flask(__name__)
+
+class SafeJSONEncoder(json.JSONEncoder):
+    """JSON encoder that handles NaN, Inf, numpy types, pandas types."""
+    def default(self, obj):
+        if isinstance(obj, (np.integer,)): return int(obj)
+        if isinstance(obj, (np.floating,)):
+            f = float(obj)
+            if math.isnan(f) or math.isinf(f): return None
+            return f
+        if isinstance(obj, (np.bool_,)): return bool(obj)
+        if isinstance(obj, np.ndarray): return obj.tolist()
+        if isinstance(obj, (pd.Timestamp, pd.Period)): return str(obj)
+        if hasattr(obj, 'item'): return obj.item()
+        return super().default(obj)
+
+def safe_jsonify(data, status=200):
+    """Serialize to JSON safely, replacing NaN/Inf with null."""
+    text = json.dumps(data, cls=SafeJSONEncoder, allow_nan=True)
+    # Replace JavaScript-invalid NaN/Infinity tokens with null
+    text = text.replace(': NaN', ': null').replace(':NaN', ':null')
+    text = text.replace(': Infinity', ': null').replace(':Infinity', ':null')
+    text = text.replace(': -Infinity', ': null').replace(':-Infinity', ':null')
+    return Response(text, status=status, mimetype='application/json')
+
+FMP_API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+GEMINI_API_KEY = "AIzaSyBX8v2d_UV_Hktcj-AvV7TyR6TD5grn24w"  # fallback
+ALPHA_VANTAGE_KEY = "P0D5N0A8SVC00YUW"
+FINNHUB_KEY = "d6ao9dhr01qqjvbr6m1gd6ao9dhr01qqjvbr6m20"
+FRED_KEY = "010a35b0ca89efdef4234f33c5089d7a"
+
+# ── AI Backend: Ollama (local) with Gemini fallback ──────
+OLLAMA_URL = "http://localhost:11434"
+OLLAMA_MODEL = "llama3.1"  # 8B params, runs well on 3050 GPU
+
+def call_ai(prompt):
+    """Try Ollama local first, fall back to Gemini API if unavailable."""
+    # Try Ollama (local, free, instant)
+    try:
+        r = http_requests.post(f"{OLLAMA_URL}/api/generate", json={
+            "model": OLLAMA_MODEL,
+            "prompt": prompt,
+            "stream": False,
+            "options": {"temperature": 0.7, "num_predict": 2048}
+        }, timeout=120)
+        if r.status_code == 200:
+            return r.json().get("response", "")
+    except Exception as e:
+        print(f"Ollama unavailable: {e}")
+
+    # Fallback: Gemini API
+    try:
+        from google import genai
+        client = genai.Client(api_key=GEMINI_API_KEY)
+        response = client.models.generate_content(model="gemini-2.0-flash", contents=prompt)
+        return response.text
+    except Exception as e:
+        print(f"Gemini fallback also failed: {e}")
+        return None
+
+# ── TICKER DATABASE ──────────────────────────────────────
+TICKER_DB = [
+    ("AAPL","Apple"),("ABBV","AbbVie"),("ABT","Abbott Labs"),("ACN","Accenture"),
+    ("ADBE","Adobe"),("ADI","Analog Devices"),("ADM","Archer-Daniels"),("ADP","ADP"),
+    ("ADSK","Autodesk"),("AEP","American Electric"),("AFL","Aflac"),("AIG","AIG"),
+    ("AMAT","Applied Materials"),("AMD","AMD"),("AMGN","Amgen"),("AMP","Ameriprise"),
+    ("AMZN","Amazon"),("ANET","Arista Networks"),("ANSS","Ansys"),("AON","Aon"),
+    ("APD","Air Products"),("APH","Amphenol"),("AVGO","Broadcom"),("AXP","American Express"),
+    ("BA","Boeing"),("BAC","Bank of America"),("BAX","Baxter"),("BDX","Becton Dickinson"),
+    ("BK","Bank of NY Mellon"),("BKNG","Booking Holdings"),("BLK","BlackRock"),
+    ("BMY","Bristol-Myers"),("BRK.B","Berkshire Hathaway"),("BSX","Boston Scientific"),
+    ("C","Citigroup"),("CAT","Caterpillar"),("CB","Chubb"),("CCI","Crown Castle"),
+    ("CDNS","Cadence Design"),("CI","Cigna"),("CL","Colgate-Palmolive"),("CMCSA","Comcast"),
+    ("CME","CME Group"),("CNC","Centene"),("COF","Capital One"),("COP","ConocoPhillips"),
+    ("COST","Costco"),("CRM","Salesforce"),("CSCO","Cisco"),("CTAS","Cintas"),
+    ("CVS","CVS Health"),("CVX","Chevron"),("D","Dominion Energy"),("DD","DuPont"),
+    ("DE","Deere & Co"),("DHR","Danaher"),("DIS","Disney"),("DLTR","Dollar Tree"),
+    ("DOW","Dow Inc"),("DUK","Duke Energy"),("DVN","Devon Energy"),("DXCM","DexCom"),
+    ("EA","Electronic Arts"),("EBAY","eBay"),("ECL","Ecolab"),("EL","Estee Lauder"),
+    ("EMR","Emerson"),("ENPH","Enphase Energy"),("EOG","EOG Resources"),("EQIX","Equinix"),
+    ("EW","Edwards Lifesciences"),("EXC","Exelon"),("F","Ford"),("FAST","Fastenal"),
+    ("FCX","Freeport-McMoRan"),("FDX","FedEx"),("FSLR","First Solar"),
+    ("GD","General Dynamics"),("GE","GE Aerospace"),("GILD","Gilead"),("GIS","General Mills"),
+    ("GM","General Motors"),("GOOG","Alphabet A"),("GOOGL","Alphabet C"),("GPN","Global Payments"),
+    ("GS","Goldman Sachs"),("HAL","Halliburton"),("HD","Home Depot"),("HON","Honeywell"),
+    ("HPQ","HP Inc"),("HUM","Humana"),("IBM","IBM"),("ICE","Intercontinental Exchange"),
+    ("IDXX","IDEXX Labs"),("ILMN","Illumina"),("INTC","Intel"),("INTU","Intuit"),
+    ("ISRG","Intuitive Surgical"),("ITW","Illinois Tool Works"),("JCI","Johnson Controls"),
+    ("JNJ","Johnson & Johnson"),("JPM","JPMorgan Chase"),("KHC","Kraft Heinz"),
+    ("KLAC","KLA Corp"),("KMB","Kimberly-Clark"),("KO","Coca-Cola"),("LEN","Lennar"),
+    ("LHX","L3Harris"),("LIN","Linde"),("LLY","Eli Lilly"),("LMT","Lockheed Martin"),
+    ("LOW","Lowe's"),("LRCX","Lam Research"),("LULU","Lululemon"),("MA","Mastercard"),
+    ("MAR","Marriott"),("MCD","McDonald's"),("MCHP","Microchip Tech"),("MCK","McKesson"),
+    ("MCO","Moody's"),("MDLZ","Mondelez"),("MDT","Medtronic"),("MET","MetLife"),
+    ("META","Meta Platforms"),("MMC","Marsh McLennan"),("MMM","3M"),("MO","Altria"),
+    ("MPC","Marathon Petroleum"),("MRK","Merck"),("MRNA","Moderna"),("MS","Morgan Stanley"),
+    ("MSFT","Microsoft"),("MSI","Motorola Solutions"),("MU","Micron"),("NFLX","Netflix"),
+    ("NKE","Nike"),("NOC","Northrop Grumman"),("NOW","ServiceNow"),("NSC","Norfolk Southern"),
+    ("NTAP","NetApp"),("NVDA","NVIDIA"),("NVO","Novo Nordisk"),("NXPI","NXP Semi"),
+    ("O","Realty Income"),("ODFL","Old Dominion"),("ON","ON Semi"),("ORCL","Oracle"),
+    ("ORLY","O'Reilly Auto"),("OXY","Occidental"),("PANW","Palo Alto Networks"),
+    ("PARA","Paramount"),("PCAR","PACCAR"),("PEP","PepsiCo"),("PFE","Pfizer"),
+    ("PG","Procter & Gamble"),("PGR","Progressive"),("PLD","Prologis"),("PLTR","Palantir"),
+    ("PM","Philip Morris"),("PNC","PNC Financial"),("PSA","Public Storage"),("PSX","Phillips 66"),
+    ("PYPL","PayPal"),("QCOM","Qualcomm"),("REGN","Regeneron"),("RIVN","Rivian"),
+    ("ROKU","Roku"),("ROP","Roper Tech"),("ROST","Ross Stores"),("RTX","RTX Corp"),
+    ("SBUX","Starbucks"),("SCHW","Charles Schwab"),("SHW","Sherwin-Williams"),
+    ("SLB","Schlumberger"),("SMCI","Super Micro"),("SNAP","Snap Inc"),("SNPS","Synopsys"),
+    ("SO","Southern Co"),("SOFI","SoFi"),("SPG","Simon Property"),("SPGI","S&P Global"),
+    ("SQ","Block Inc"),("SRE","Sempra"),("STZ","Constellation Brands"),("SYK","Stryker"),
+    ("SYY","Sysco"),("T","AT&T"),("TDG","TransDigm"),("TGT","Target"),("TJX","TJX Cos"),
+    ("TMO","Thermo Fisher"),("TMUS","T-Mobile"),("TSLA","Tesla"),("TSM","TSMC"),
+    ("TSN","Tyson Foods"),("TXN","Texas Instruments"),("UNH","UnitedHealth"),
+    ("UNP","Union Pacific"),("UPS","UPS"),("URI","United Rentals"),("USB","US Bancorp"),
+    ("V","Visa"),("VLO","Valero Energy"),("VRSK","Verisk"),("VRTX","Vertex Pharma"),
+    ("VZ","Verizon"),("WBA","Walgreens"),("WBD","Warner Bros Discovery"),("WELL","Welltower"),
+    ("WFC","Wells Fargo"),("WM","Waste Management"),("WMT","Walmart"),("XEL","Xcel Energy"),
+    ("XOM","ExxonMobil"),("ZM","Zoom"),("ZTS","Zoetis"),
+    ("RELIANCE.NS","Reliance Industries"),("TCS.NS","TCS"),("INFY.NS","Infosys"),
+    ("HDFCBANK.NS","HDFC Bank"),("ICICIBANK.NS","ICICI Bank"),("SBIN.NS","SBI"),
+    ("BHARTIARTL.NS","Bharti Airtel"),("ITC.NS","ITC"),("KOTAKBANK.NS","Kotak Bank"),
+    ("LT.NS","Larsen & Toubro"),("HINDUNILVR.NS","Hindustan Unilever"),
+    ("BAJFINANCE.NS","Bajaj Finance"),("MARUTI.NS","Maruti Suzuki"),("WIPRO.NS","Wipro"),
+    ("TATAMOTORS.NS","Tata Motors"),("TATASTEEL.NS","Tata Steel"),("SUNPHARMA.NS","Sun Pharma"),
+    ("AXISBANK.NS","Axis Bank"),("ONGC.NS","ONGC"),("NTPC.NS","NTPC"),
+    ("ADANIENT.NS","Adani Enterprises"),("TITAN.NS","Titan"),("ASIANPAINT.NS","Asian Paints"),
+    # ── Futures ──
+    ("ES=F","S&P 500 Futures"),("NQ=F","Nasdaq 100 Futures"),("YM=F","Dow Futures"),
+    ("RTY=F","Russell 2000 Futures"),("GC=F","Gold Futures"),("SI=F","Silver Futures"),
+    ("CL=F","Crude Oil WTI Futures"),("BZ=F","Brent Crude Futures"),("NG=F","Natural Gas Futures"),
+    ("ZC=F","Corn Futures"),("ZW=F","Wheat Futures"),("ZS=F","Soybean Futures"),
+    ("HG=F","Copper Futures"),("PL=F","Platinum Futures"),("PA=F","Palladium Futures"),
+    ("ZB=F","US Treasury Bond Futures"),("ZN=F","10-Year Note Futures"),
+    # ── Currency Pairs ──
+    ("EURUSD=X","EUR/USD"),("GBPUSD=X","GBP/USD"),("USDJPY=X","USD/JPY"),
+    ("USDCHF=X","USD/CHF"),("AUDUSD=X","AUD/USD"),("USDCAD=X","USD/CAD"),
+    ("NZDUSD=X","NZD/USD"),("USDINR=X","USD/INR"),("GBPINR=X","GBP/INR"),
+    ("EURINR=X","EUR/INR"),("USDHKD=X","USD/HKD"),("USDSGD=X","USD/SGD"),
+    ("EURGBP=X","EUR/GBP"),("EURJPY=X","EUR/JPY"),("GBPJPY=X","GBP/JPY"),
+    # ── Indices (ETFs) ──
+    ("SPY","SPDR S&P 500 ETF"),("QQQ","Invesco Nasdaq 100 ETF"),("DIA","SPDR Dow Jones ETF"),
+    ("IWM","iShares Russell 2000"),("VTI","Vanguard Total Market"),("EEM","iShares EM ETF"),
+    ("GLD","SPDR Gold Shares"),("SLV","iShares Silver Trust"),("TLT","iShares 20+ Yr Bond"),
+    ("^NSEI","NIFTY 50"),("^BSESN","BSE SENSEX"),
+    # ── Global Indices ──
+    ("^GSPC","S&P 500"),("^IXIC","NASDAQ Composite"),("^DJI","Dow Jones Industrial"),
+    ("^FTSE","FTSE 100"),("^N225","Nikkei 225"),("^GDAXI","DAX"),("^HSI","Hang Seng"),
+    ("000001.SS","Shanghai Composite"),("^AXJO","ASX 200"),("^FCHI","CAC 40"),
+    ("^RUT","Russell 2000"),("^VIX","CBOE Volatility Index"),
+]
+
+# ── SECTOR PEER GROUPS ───────────────────────────────────
+SECTOR_PEERS = {
+    "tech": ["AAPL","MSFT","GOOGL","META","AMZN","NVDA","TSLA","AMD","INTC","CRM","ADBE","ORCL","IBM","NOW","AVGO"],
+    "finance": ["JPM","BAC","GS","MS","WFC","C","BLK","SCHW","AXP","COF","PNC","USB","BK","MCO","SPGI"],
+    "healthcare": ["JNJ","UNH","PFE","MRK","ABBV","LLY","TMO","ABT","BMY","AMGN","GILD","MDT","ISRG","REGN","VRTX"],
+    "consumer": ["PG","KO","PEP","COST","WMT","HD","MCD","NKE","SBUX","TGT","CL","EL","KHC","MDLZ","GIS"],
+    "energy": ["XOM","CVX","COP","EOG","OXY","SLB","HAL","DVN","MPC","VLO","PSX"],
+    "industrial": ["CAT","DE","HON","BA","GE","RTX","LMT","NOC","GD","EMR","ITW","UNP","UPS","FDX"],
+    "telecom": ["T","VZ","TMUS","CMCSA"],
+}
+
+def get_peers(ticker):
+    t = ticker.upper()
+    for sector, tickers in SECTOR_PEERS.items():
+        if t in tickers:
+            return [p for p in tickers if p != t][:5], sector
+    return [], "unknown"
+
+def safe_val(val):
+    if val is None: return None
+    if isinstance(val, (np.integer,)): return int(val)
+    if isinstance(val, (np.floating,)): return float(val)
+    if isinstance(val, (np.bool_,)): return bool(val)
+    if isinstance(val, pd.Timestamp): return str(val)
+    if isinstance(val, (pd.Series, pd.DataFrame)):
+        return safe_val(val.iloc[-1] if len(val) > 0 else 0)
+    if hasattr(val, 'item'): return val.item()
+    return val
+
+def safe_num(val, decimals=2):
+    v = safe_val(val)
+    if v is None or (isinstance(v, float) and (np.isnan(v) or np.isinf(v))):
+        return "N/A"
+    try: return round(float(v), decimals)
+    except: return "N/A"
+
+def sanitize_for_json(obj):
+    """Recursively clean NaN/Inf/numpy types so jsonify won't crash on Windows."""
+    if isinstance(obj, dict):
+        return {k: sanitize_for_json(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [sanitize_for_json(v) for v in obj]
+    if isinstance(obj, float):
+        if np.isnan(obj) or np.isinf(obj): return None
+        return obj
+    if isinstance(obj, (np.integer,)): return int(obj)
+    if isinstance(obj, (np.floating,)):
+        f = float(obj)
+        return None if np.isnan(f) or np.isinf(f) else f
+    if isinstance(obj, (np.bool_,)): return bool(obj)
+    if isinstance(obj, (pd.Timestamp, pd.Period)): return str(obj)
+    if hasattr(obj, 'item'): return obj.item()
+    return obj
+
+def get_fin_val(df, ticker, row_label):
+    try:
+        if isinstance(df.columns, pd.MultiIndex):
+            if ticker in df.columns.get_level_values(1):
+                df = df.xs(ticker, level=1, axis=1)
+            elif ticker in df.columns.get_level_values(0):
+                df = df.xs(ticker, level=0, axis=1)
+        if row_label in df.index:
+            return safe_num(df.loc[row_label].iloc[-1])
+    except: pass
+    return "N/A"
+
+# ── Route: Dashboard ─────────────────────────────────────
+@app.route("/")
+def index():
+    return render_template("index.html")
+
+# ── Route: Ticker Suggestions ────────────────────────────
+@app.route("/api/suggest", methods=["GET"])
+def suggest():
+    q = request.args.get("q", "").upper().strip()
+    asset_type = request.args.get("asset_type", "").lower().strip()
+    if len(q) < 1: return safe_jsonify([])
+
+    def matches_asset_type(ticker):
+        if not asset_type: return True
+        if asset_type == "stocks":
+            return not ticker.endswith("=F") and not ticker.endswith("=X")
+        elif asset_type == "futures":
+            return ticker.endswith("=F")
+        elif asset_type == "currencies":
+            return ticker.endswith("=X")
+        elif asset_type == "options":
+            return not ticker.endswith("=F") and not ticker.endswith("=X") and not ticker.startswith("^")
+        return True
+
+    results = []
+    for ticker, name in TICKER_DB:
+        if not matches_asset_type(ticker): continue
+        score = 0
+        if ticker.upper().startswith(q): score = 100 + (10 - len(ticker))
+        elif q in ticker.upper(): score = 80
+        elif q in name.upper(): score = 70
+        else:
+            ratio = SequenceMatcher(None, q, ticker.upper()).ratio()
+            name_ratio = SequenceMatcher(None, q, name.upper()).ratio()
+            best = max(ratio, name_ratio)
+            if best > 0.5: score = int(best * 60)
+        if score > 0:
+            results.append({"ticker": ticker, "name": name, "score": score})
+    results.sort(key=lambda x: -x["score"])
+    return safe_jsonify(results[:10])
+
+# ── Route: Full Analysis ─────────────────────────────────
+@app.route("/api/analyze", methods=["POST"])
+def analyze():
+    data = request.json
+    ticker = data.get("ticker", "AAPL").upper().strip()
+    period = data.get("period", "yearly")
+    start_date = data.get("start_date", "")
+    end_date = data.get("end_date", "")
+
+    timeframe = data.get("timeframe", "1Y")
+    if not start_date:
+        offsets = {"1M": 30, "3M": 90, "6M": 180, "1Y": 365, "2Y": 730, "5Y": 1825, "MAX": 7300}
+        days = offsets.get(timeframe, 365)
+        start_date = (datetime.now() - timedelta(days=days)).strftime("%Y-%m-%d")
+    if not end_date:
+        end_date = datetime.now().strftime("%Y-%m-%d")
+
+    try:
+        # Chart data uses the user's timeframe
+        hist = None
+        try:
+            chart_toolkit = Toolkit(tickers=[ticker], api_key=FMP_API_KEY, start_date=start_date, end_date=end_date)
+            hist = chart_toolkit.get_historical_data(period="daily")
+        except OSError as oe:
+            print(f"FinanceToolkit OSError (Windows caching): {oe}")
+            # Fallback: use yfinance for price history
+            import yfinance as yf
+            yf_ticker = yf.Ticker(ticker)
+            yf_hist = yf_ticker.history(start=start_date, end=end_date)
+            if not yf_hist.empty:
+                yf_hist.index.name = 'date'
+                yf_hist.columns = pd.MultiIndex.from_product([yf_hist.columns, [ticker]])
+                hist = yf_hist
+        except Exception as e:
+            print(f"FinanceToolkit error: {e}")
+            # Fallback: use yfinance
+            import yfinance as yf
+            yf_ticker = yf.Ticker(ticker)
+            yf_hist = yf_ticker.history(start=start_date, end=end_date)
+            if not yf_hist.empty:
+                yf_hist.index.name = 'date'
+                yf_hist.columns = pd.MultiIndex.from_product([yf_hist.columns, [ticker]])
+                hist = yf_hist
+
+        if hist is None or hist.empty:
+            return safe_jsonify({"error": f"No data found for {ticker}"}), 404
+
+        if isinstance(hist.columns, pd.MultiIndex):
+            if ticker in hist.columns.get_level_values(1):
+                hd = hist.xs(ticker, level=1, axis=1)
+            elif ticker in hist.columns.get_level_values(0):
+                hd = hist.xs(ticker, level=0, axis=1)
+            else: hd = hist
+        else: hd = hist
+
+        close = hd['Close']
+        price = safe_num(close.iloc[-1])
+
+        # Compute technicals from price data
+        delta = close.diff()
+        gain = delta.where(delta > 0, 0).rolling(14).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(14).mean()
+        rs = gain / loss
+        rsi = safe_num(100 - (100 / (1 + rs)).iloc[-1])
+
+        ema5 = safe_num(close.ewm(span=5).mean().iloc[-1])
+        ema10 = safe_num(close.ewm(span=10).mean().iloc[-1])
+        ema20 = safe_num(close.ewm(span=20).mean().iloc[-1])
+        ema50 = safe_num(close.ewm(span=50).mean().iloc[-1])
+        sma200 = safe_num(close.rolling(200).mean().iloc[-1])
+
+        ema12 = close.ewm(span=12).mean()
+        ema26 = close.ewm(span=26).mean()
+        macd_line = ema12 - ema26
+        signal_line = macd_line.ewm(span=9).mean()
+        macd_val = safe_num(macd_line.iloc[-1])
+        macd_signal = safe_num(signal_line.iloc[-1])
+
+        ma20 = close.rolling(20).mean()
+        std20 = close.rolling(20).std()
+        bb_upper = safe_num((ma20 + 2 * std20).iloc[-1])
+        bb_lower = safe_num((ma20 - 2 * std20).iloc[-1])
+
+        tr = pd.concat([hd['High'] - hd['Low'], (hd['High'] - close.shift()).abs(), (hd['Low'] - close.shift()).abs()], axis=1).max(axis=1)
+        atr = safe_num(tr.rolling(14).mean().iloc[-1])
+
+        vol = safe_num(hd['Volume'].iloc[-1])
+        avg_vol = safe_num(hd['Volume'].rolling(20).mean().iloc[-1])
+
+        technicals = {
+            "price": price, "ema_5": ema5, "ema_10": ema10, "ema_20": ema20,
+            "ema_50": ema50, "sma_200": sma200,
+            "rsi": rsi, "macd": macd_val, "macd_signal": macd_signal,
+            "bb_upper": bb_upper, "bb_lower": bb_lower, "atr": atr,
+            "volume": vol, "avg_volume_20": avg_vol
+        }
+
+        # ── FINANCIALS — always fetch with 5Y lookback ──
+        fin_toolkit = Toolkit(tickers=[ticker], api_key=FMP_API_KEY,
+                              quarterly=(period == "quarterly"))
+        financials = {}
+        try:
+            income = fin_toolkit.get_income_statement()
+            balance = fin_toolkit.get_balance_sheet_statement()
+            financials = {
+                "revenue": get_fin_val(income, ticker, "Revenue"),
+                "cost_of_goods": get_fin_val(income, ticker, "Cost of Goods Sold"),
+                "gross_profit": get_fin_val(income, ticker, "Gross Profit"),
+                "operating_income": get_fin_val(income, ticker, "Operating Income"),
+                "ebitda": get_fin_val(income, ticker, "EBITDA"),
+                "net_income": get_fin_val(income, ticker, "Net Income"),
+                "eps": get_fin_val(income, ticker, "EPS"),
+                "eps_diluted": get_fin_val(income, ticker, "EPS Diluted"),
+                "total_assets": get_fin_val(balance, ticker, "Total Assets"),
+                "total_debt": get_fin_val(balance, ticker, "Total Debt"),
+                "net_debt": get_fin_val(balance, ticker, "Net Debt"),
+                "cash": get_fin_val(balance, ticker, "Cash and Cash Equivalents"),
+                "total_equity": get_fin_val(balance, ticker, "Total Equity"),
+                "retained_earnings": get_fin_val(balance, ticker, "Retained Earnings"),
+            }
+        except Exception as e:
+            financials = {"error": str(e)}
+
+        # ── RATIOS ──
+        ratios = {}
+        try:
+            prof = fin_toolkit.ratios.collect_profitability_ratios()
+            val = fin_toolkit.ratios.collect_valuation_ratios()
+            ratios = {
+                "gross_margin": get_fin_val(prof, ticker, "Gross Margin"),
+                "operating_margin": get_fin_val(prof, ticker, "Operating Margin"),
+                "net_profit_margin": get_fin_val(prof, ticker, "Net Profit Margin"),
+                "roe": get_fin_val(prof, ticker, "Return on Equity"),
+                "roa": get_fin_val(prof, ticker, "Return on Assets"),
+                "roic": get_fin_val(prof, ticker, "Return on Invested Capital"),
+                "pe_ratio": get_fin_val(val, ticker, "Price-to-Earnings"),
+                "pb_ratio": get_fin_val(val, ticker, "Price-to-Book"),
+                "ev_ebitda": get_fin_val(val, ticker, "EV-to-EBITDA"),
+                "ev_sales": get_fin_val(val, ticker, "EV-to-Sales"),
+                "dividend_yield": get_fin_val(val, ticker, "Dividend Yield"),
+                "market_cap": get_fin_val(val, ticker, "Market Cap"),
+            }
+        except Exception as e:
+            ratios = {"error": str(e)}
+
+        # ── FCFF ──
+        fcff = {}
+        try:
+            cf = fin_toolkit.get_cash_flow_statement()
+            fcff = {
+                "cash_flow_from_operations": get_fin_val(cf, ticker, "Cash Flow from Operations"),
+                "capital_expenditure": get_fin_val(cf, ticker, "Capital Expenditure"),
+                "free_cash_flow": get_fin_val(cf, ticker, "Free Cash Flow"),
+                "net_change_in_cash": get_fin_val(cf, ticker, "Net Change in Cash"),
+                "cash_flow_from_investing": get_fin_val(cf, ticker, "Cash Flow from Investing"),
+                "cash_flow_from_financing": get_fin_val(cf, ticker, "Cash Flow from Financing"),
+                "dividends_paid": get_fin_val(cf, ticker, "Dividends Paid"),
+                "stock_based_compensation": get_fin_val(cf, ticker, "Stock Based Compensation"),
+            }
+        except Exception as e:
+            fcff = {"error": str(e)}
+
+        # ── Full price history for interactive chart ──
+        price_history = []
+        try:
+            for date, row in hd.iterrows():
+                price_history.append({
+                    "date": str(date)[:10],
+                    "open": safe_num(row.get('Open', 0)),
+                    "high": safe_num(row.get('High', 0)),
+                    "low": safe_num(row.get('Low', 0)),
+                    "close": safe_num(row['Close']),
+                    "volume": safe_num(row['Volume'])
+                })
+        except: pass
+
+        result = sanitize_for_json({
+            "ticker": ticker, "technicals": technicals,
+            "financials": financials, "ratios": ratios, "fcff": fcff,
+            "price_history": price_history,
+            "date_range": {"start": start_date, "end": end_date}
+        })
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Competitor Analysis ───────────────────────────
+def get_multi_val(df, ticker, metric):
+    """Extract value from multi-ticker financetoolkit DataFrame.
+    Multi-ticker DataFrames have a row MultiIndex: (ticker, metric). Columns are year periods."""
+    try:
+        if isinstance(df.index, pd.MultiIndex):
+            if (ticker, metric) in df.index:
+                row = df.loc[(ticker, metric)]
+                return safe_num(row.iloc[-1])
+        else:
+            if metric in df.index:
+                return safe_num(df.loc[metric].iloc[-1])
+    except: pass
+    return "N/A"
+
+@app.route("/api/competitors", methods=["POST"])
+def competitors():
+    data = request.json
+    ticker = data.get("ticker", "AAPL").upper().strip()
+    peers, sector = get_peers(ticker)
+
+    if not peers:
+        return safe_jsonify({"sector": "unknown", "peers": [], "message": "No peer data available for this ticker."})
+
+    try:
+        all_tickers = [ticker] + peers
+        comp_toolkit = Toolkit(tickers=all_tickers, api_key=FMP_API_KEY)
+        val = comp_toolkit.ratios.collect_valuation_ratios()
+        prof = comp_toolkit.ratios.collect_profitability_ratios()
+
+        result = []
+        for t in all_tickers:
+            entry = {"ticker": t, "is_target": (t == ticker)}
+            entry["pe_ratio"] = get_multi_val(val, t, "Price-to-Earnings")
+            entry["pb_ratio"] = get_multi_val(val, t, "Price-to-Book")
+            entry["ev_ebitda"] = get_multi_val(val, t, "EV-to-EBITDA")
+            entry["ev_sales"] = get_multi_val(val, t, "EV-to-Sales")
+            entry["market_cap"] = get_multi_val(val, t, "Market Cap")
+            entry["net_margin"] = get_multi_val(prof, t, "Net Profit Margin")
+            entry["roe"] = get_multi_val(prof, t, "Return on Equity")
+            entry["gross_margin"] = get_multi_val(prof, t, "Gross Margin")
+            result.append(entry)
+
+        return safe_jsonify({"sector": sector, "peers": result})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"sector": sector, "peers": [], "error": str(e)})
+
+# ── Route: News ──────────────────────────────────────────
+@app.route("/api/news", methods=["POST"])
+def news():
+    data = request.json
+    ticker = data.get("ticker", "AAPL").upper().strip()
+    try:
+        encoded = ticker.replace("&", "%26")
+        rss_url = f"https://news.google.com/rss/search?q={encoded}+stock&hl=en-US&gl=US&ceid=US:en"
+        feed = feedparser.parse(rss_url)
+        analyzer = SentimentIntensityAnalyzer()
+        news_items = []
+        for entry in feed.entries[:5]:
+            title = entry.title
+            sentiment = analyzer.polarity_scores(f"{title}. {entry.get('description', '')}")
+            news_items.append({
+                "title": title, "link": entry.link,
+                "published": entry.get("published", ""),
+                "sentiment_score": round(sentiment['compound'], 4),
+                "sentiment_label": "Positive" if sentiment['compound'] > 0.05 else "Negative" if sentiment['compound'] < -0.05 else "Neutral"
+            })
+        avg = sum(n['sentiment_score'] for n in news_items) / len(news_items) if news_items else 0
+        return safe_jsonify({"ticker": ticker, "news": news_items, "average_sentiment": round(avg, 4),
+                        "overall_label": "Positive" if avg > 0.05 else "Negative" if avg < -0.05 else "Neutral"})
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: AI ────────────────────────────────────────────
+@app.route("/api/ai", methods=["POST"])
+def ai_overview():
+    data = request.json
+    ticker = data.get("ticker", "")
+    analysis_data = data.get("analysis", {})
+    news_data = data.get("news", {})
+    user_question = data.get("question", "")
+
+    prompt = f"""You are a top-tier financial analyst. Here is the latest data for {ticker}:
+
+TECHNICALS:
+{json.dumps(analysis_data.get('technicals', {}), indent=2)}
+
+FINANCIALS:
+{json.dumps(analysis_data.get('financials', {}), indent=2)}
+
+RATIOS:
+{json.dumps(analysis_data.get('ratios', {}), indent=2)}
+
+FREE CASH FLOW:
+{json.dumps(analysis_data.get('fcff', {}), indent=2)}
+
+NEWS SENTIMENT:
+{json.dumps(news_data, indent=2)}
+
+Based on the data, provide:
+1. Key strengths and competitive advantages
+2. Risks and red flags
+3. Clear recommendation (Buy / Hold / Sell) with reasoning
+
+{f'The user also asks: {user_question}' if user_question else ''}
+"""
+    result = call_ai(prompt)
+    if result:
+        return safe_jsonify({"overview": result})
+    return safe_jsonify({"error": "AI unavailable. Please ensure Ollama is running: 'ollama serve' in terminal."}), 500
+
+# ── Route: Excel Export ──────────────────────────────────
+@app.route("/api/export", methods=["POST"])
+def export_excel():
+    data = request.json
+    ticker = data.get("ticker", "DATA")
+    analysis = data.get("analysis", {})
+    news_data = data.get("news", {})
+    ai_text = data.get("ai_overview", "")
+
+    wb = openpyxl.Workbook()
+    ws1 = wb.active; ws1.title = "Technicals"
+    ws1.append(["Indicator", "Value"])
+    for k, v in analysis.get("technicals", {}).items():
+        ws1.append([k.replace("_"," ").title(), str(v)])
+
+    ws2 = wb.create_sheet("Financials")
+    ws2.append(["Metric", "Value"])
+    for k, v in analysis.get("financials", {}).items():
+        ws2.append([k.replace("_"," ").title(), str(v)])
+
+    ws3 = wb.create_sheet("Ratios & Valuation")
+    ws3.append(["Ratio", "Value"])
+    for k, v in analysis.get("ratios", {}).items():
+        ws3.append([k.replace("_"," ").title(), str(v)])
+
+    ws4 = wb.create_sheet("Cash Flow (FCFF)")
+    ws4.append(["Metric", "Value"])
+    for k, v in analysis.get("fcff", {}).items():
+        ws4.append([k.replace("_"," ").title(), str(v)])
+
+    ws5 = wb.create_sheet("News & Sentiment")
+    ws5.append(["Title", "Sentiment", "Score"])
+    for n in news_data.get("news", []):
+        ws5.append([n.get("title",""), n.get("sentiment_label",""), n.get("sentiment_score","")])
+
+    ws6 = wb.create_sheet("AI Overview")
+    ws6.append(["AI Analyst Commentary"])
+    for line in ai_text.split("\n"):
+        ws6.append([line])
+
+    for ws in wb.worksheets:
+        for col in ws.columns:
+            max_len = max(len(str(c.value or "")) for c in col)
+            ws.column_dimensions[col[0].column_letter].width = min(max_len + 2, 60)
+
+    buffer = BytesIO()
+    wb.save(buffer)
+    buffer.seek(0)
+    return send_file(buffer, as_attachment=True, download_name=f"{ticker}_analysis.xlsx",
+                     mimetype="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet")
+
+# ══════════════════════════════════════════════════════════
+# STAGE 2 — NEW ENDPOINTS
+# ══════════════════════════════════════════════════════════
+
+# ── Route: DCF Intrinsic Valuation ───────────────────────
+@app.route("/api/dcf", methods=["POST"])
+def dcf_valuation():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        tk = Toolkit(tickers=[ticker], api_key=FMP_API_KEY)
+
+        income = tk.get_income_statement()
+        balance = tk.get_balance_sheet_statement()
+        cf = tk.get_cash_flow_statement()
+
+        fcf = get_fin_val(cf, ticker, "Free Cash Flow")
+        revenue = get_fin_val(income, ticker, "Revenue")
+        ebit = get_fin_val(income, ticker, "Operating Income")
+        total_debt = get_fin_val(balance, ticker, "Total Debt")
+        cash = get_fin_val(balance, ticker, "Cash and Cash Equivalents")
+        total_equity = get_fin_val(balance, ticker, "Total Equity")
+        shares = get_fin_val(income, ticker, "Weighted Average Shares Outstanding")
+        total_assets = get_fin_val(balance, ticker, "Total Assets")
+
+        if any(v == "N/A" for v in [fcf, total_debt, cash, shares, total_equity]):
+            return safe_jsonify({"error": "Insufficient data for DCF calculation", "ticker": ticker})
+
+        # WACC estimation
+        risk_free = 0.043  # ~10Y Treasury
+        equity_premium = 0.055
+        beta = 1.0  # Default
+        cost_of_equity = risk_free + beta * equity_premium
+        cost_of_debt = 0.05
+        tax_rate = 0.21
+        total_cap = abs(total_equity) + abs(total_debt) if total_debt != 0 else abs(total_equity)
+        eq_weight = abs(total_equity) / total_cap if total_cap > 0 else 0.7
+        debt_weight = 1 - eq_weight
+        wacc = eq_weight * cost_of_equity + debt_weight * cost_of_debt * (1 - tax_rate)
+        wacc = max(wacc, 0.06)
+
+        # Project FCF
+        growth_rate = 0.08   # Conservative growth
+        terminal_growth = 0.025
+        projection_years = 5
+        projected_fcf = []
+        current_fcf = float(fcf)
+        for y in range(1, projection_years + 1):
+            current_fcf *= (1 + growth_rate)
+            pv = current_fcf / ((1 + wacc) ** y)
+            projected_fcf.append({"year": y, "fcf": round(current_fcf, 0), "pv": round(pv, 0)})
+
+        # Terminal value
+        terminal_value = (current_fcf * (1 + terminal_growth)) / (wacc - terminal_growth)
+        pv_terminal = terminal_value / ((1 + wacc) ** projection_years)
+
+        # Enterprise value & intrinsic value
+        sum_pv_fcf = sum(p["pv"] for p in projected_fcf)
+        enterprise_value = sum_pv_fcf + pv_terminal
+        equity_value = enterprise_value - float(total_debt) + float(cash)
+        intrinsic_per_share = equity_value / float(shares)
+
+        # Get current price for comparison
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        current_price = stock.info.get("currentPrice", stock.info.get("previousClose", 0))
+
+        upside = ((intrinsic_per_share - current_price) / current_price * 100) if current_price > 0 else 0
+        verdict = "UNDERVALUED" if upside > 15 else "OVERVALUED" if upside < -15 else "FAIRLY VALUED"
+
+        return safe_jsonify(sanitize_for_json({
+            "ticker": ticker, "intrinsic_value": round(intrinsic_per_share, 2),
+            "current_price": round(current_price, 2), "upside_pct": round(upside, 2),
+            "verdict": verdict,
+            "wacc": round(wacc * 100, 2), "growth_rate": growth_rate * 100,
+            "terminal_growth": terminal_growth * 100,
+            "enterprise_value": round(enterprise_value, 0),
+            "projected_fcf": projected_fcf,
+            "pv_terminal": round(pv_terminal, 0),
+            "base_fcf": round(float(fcf), 0)
+        }))
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Candlestick Pattern Recognition ───────────────
+@app.route("/api/patterns", methods=["POST"])
+def candlestick_patterns():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        prices = data.get("prices", [])
+        lookback = int(data.get("lookback_days", 7))
+        if len(prices) < 5:
+            return safe_jsonify({"patterns": [], "message": "Not enough price data"})
+
+        # Filter to last N trading days (default 7) unless custom range requested
+        analysis_prices = prices[-max(lookback + 3, 10):]  # extra context for multi-candle patterns
+
+        predictions = {
+            "Doji": "Indecision detected — watch for a breakout in either direction over the next 1-3 days. If followed by a bullish candle, expect upside; if bearish, expect downside.",
+            "Hammer": "Buyers are stepping in at lower levels. Expect a potential bullish reversal in the next 2-5 days if volume confirms.",
+            "Shooting Star": "Sellers are pushing back at higher levels. Watch for a bearish pullback over the next 2-5 days.",
+            "Bullish Engulfing": "Strong buying pressure — expect continuation higher over the next 3-7 days. Consider setting a stop below the engulfing candle low.",
+            "Bearish Engulfing": "Strong selling pressure — expect further downside in the next 3-7 days. The engulfing high acts as resistance.",
+            "Morning Star": "Classic bottom reversal. Expect a 3-7 day rally from current levels. Pattern reliability: ~70% historically.",
+            "Evening Star": "Classic top reversal. Expect a 3-7 day decline. Pattern reliability: ~70% historically.",
+            "Bullish Harami": "Selling momentum is fading. Watch for bullish confirmation candle tomorrow — if it appears, expect 2-5 days upside.",
+            "Bearish Harami": "Buying momentum is fading. Watch for bearish confirmation candle tomorrow — if it appears, expect 2-5 days downside.",
+        }
+
+        patterns_found = []
+        for i in range(2, len(analysis_prices)):
+            o, h, l, c = analysis_prices[i]["open"], analysis_prices[i]["high"], analysis_prices[i]["low"], analysis_prices[i]["close"]
+            body = abs(c - o)
+            total_range = h - l
+            if total_range == 0: continue
+            body_ratio = body / total_range
+            prev_o, prev_c = analysis_prices[i-1]["open"], analysis_prices[i-1]["close"]
+            prev_body = abs(prev_c - prev_o)
+            date = analysis_prices[i]["date"]
+
+            lower_shadow = min(o, c) - l
+            upper_shadow = h - max(o, c)
+
+            detected = []
+
+            if body_ratio < 0.1 and total_range > 0:
+                detected.append({"pattern": "Doji", "type": "neutral", "description": "Indecision candle — body is tiny relative to range. Potential reversal signal."})
+
+            if body_ratio < 0.35 and lower_shadow > body * 2 and upper_shadow < body * 0.5 and c > o:
+                detected.append({"pattern": "Hammer", "type": "bullish", "description": "Bullish reversal — long lower wick shows buyers stepped in."})
+
+            if body_ratio < 0.35 and upper_shadow > body * 2 and lower_shadow < body * 0.5 and c < o:
+                detected.append({"pattern": "Shooting Star", "type": "bearish", "description": "Bearish reversal — long upper wick shows sellers pushed price down."})
+
+            if i >= 2 and prev_c < prev_o and c > o and c > prev_o and o < prev_c and body > prev_body:
+                detected.append({"pattern": "Bullish Engulfing", "type": "bullish", "description": "Strong bullish reversal — today's green candle engulfs yesterday's red candle."})
+
+            if i >= 2 and prev_c > prev_o and c < o and c < prev_o and o > prev_c and body > prev_body:
+                detected.append({"pattern": "Bearish Engulfing", "type": "bearish", "description": "Strong bearish reversal — today's red candle engulfs yesterday's green candle."})
+
+            if i >= 3:
+                p2_o, p2_c = analysis_prices[i-2]["open"], analysis_prices[i-2]["close"]
+                p1_o, p1_c = analysis_prices[i-1]["open"], analysis_prices[i-1]["close"]
+                p2_body = abs(p2_c - p2_o)
+                p1_body = abs(p1_c - p1_o)
+                if p2_c < p2_o and p2_body > 0 and p1_body < p2_body * 0.3 and c > o and body > p2_body * 0.5:
+                    detected.append({"pattern": "Morning Star", "type": "bullish", "description": "Bullish reversal — big red candle, small body, then big green candle."})
+                if p2_c > p2_o and p2_body > 0 and p1_body < p2_body * 0.3 and c < o and body > p2_body * 0.5:
+                    detected.append({"pattern": "Evening Star", "type": "bearish", "description": "Bearish reversal — big green candle, small body, then big red candle."})
+
+            if i >= 2 and prev_c < prev_o and c > o and o > prev_c and c < prev_o:
+                detected.append({"pattern": "Bullish Harami", "type": "bullish", "description": "Potential bullish reversal — small green candle inside previous red candle."})
+
+            if i >= 2 and prev_c > prev_o and c < o and o < prev_c and c > prev_o:
+                detected.append({"pattern": "Bearish Harami", "type": "bearish", "description": "Potential bearish reversal — small red candle inside previous green candle."})
+
+            for p in detected:
+                p["date"] = date
+                p["prediction"] = predictions.get(p["pattern"], "Monitor closely for confirmation.")
+                patterns_found.append(p)
+
+        # Aggregate prediction outlook
+        bullish = sum(1 for p in patterns_found if p["type"] == "bullish")
+        bearish = sum(1 for p in patterns_found if p["type"] == "bearish")
+        neutral = sum(1 for p in patterns_found if p["type"] == "neutral")
+        if bullish > bearish + neutral:
+            outlook = "BULLISH — Majority of recent patterns signal upside. Consider entries on pullbacks."
+        elif bearish > bullish + neutral:
+            outlook = "BEARISH — Majority of recent patterns signal downside. Exercise caution."
+        else:
+            outlook = "MIXED/NEUTRAL — Conflicting signals. Wait for clearer pattern confirmation."
+
+        return safe_jsonify({"patterns": patterns_found, "total_found": len(patterns_found),
+                            "outlook": outlook, "lookback_days": lookback,
+                            "bullish_count": bullish, "bearish_count": bearish, "neutral_count": neutral})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Analyst Ratings & Price Targets (Finnhub) ─────
+@app.route("/api/analyst", methods=["POST"])
+def analyst_ratings():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import requests as req
+
+        # Recommendations
+        rec_url = f"https://finnhub.io/api/v1/stock/recommendation?symbol={ticker}&token={FINNHUB_KEY}"
+        rec_resp = req.get(rec_url, timeout=10).json()
+        latest = rec_resp[0] if isinstance(rec_resp, list) and len(rec_resp) > 0 else None
+
+        # Price target
+        pt_url = f"https://finnhub.io/api/v1/stock/price-target?symbol={ticker}&token={FINNHUB_KEY}"
+        pt_resp = req.get(pt_url, timeout=10).json()
+
+        if latest is None:
+            return safe_jsonify({
+                "ticker": ticker,
+                "recommendation": {"buy": "N/A", "hold": "N/A", "sell": "N/A", "strong_buy": "N/A", "strong_sell": "N/A", "period": "N/A"},
+                "price_target": {"high": "N/A", "low": "N/A", "mean": "N/A", "median": "N/A"},
+                "available": False
+            })
+
+        return safe_jsonify(sanitize_for_json({
+            "ticker": ticker,
+            "available": True,
+            "recommendation": {
+                "buy": latest.get("buy", 0), "hold": latest.get("hold", 0),
+                "sell": latest.get("sell", 0), "strong_buy": latest.get("strongBuy", 0),
+                "strong_sell": latest.get("strongSell", 0), "period": latest.get("period", ""),
+            },
+            "price_target": {
+                "high": pt_resp.get("targetHigh") if pt_resp.get("targetHigh") else "N/A",
+                "low": pt_resp.get("targetLow") if pt_resp.get("targetLow") else "N/A",
+                "mean": pt_resp.get("targetMean") if pt_resp.get("targetMean") else "N/A",
+                "median": pt_resp.get("targetMedian") if pt_resp.get("targetMedian") else "N/A",
+            }
+        }))
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Insider Trading (Finnhub) ─────────────────────
+@app.route("/api/insider", methods=["POST"])
+def insider_trading():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import requests as req
+        url = f"https://finnhub.io/api/v1/stock/insider-transactions?symbol={ticker}&token={FINNHUB_KEY}"
+        resp = req.get(url, timeout=10).json()
+        txns = resp.get("data", [])[:20]  # Last 20
+
+        result = []
+        for t in txns:
+            result.append({
+                "name": t.get("name", "Unknown"),
+                "share": safe_num(t.get("share", 0), 0),
+                "change": safe_num(t.get("change", 0), 0),
+                "transaction_type": t.get("transactionType", ""),
+                "filing_date": t.get("filingDate", ""),
+                "transaction_date": t.get("transactionDate", ""),
+            })
+
+        return safe_jsonify({"ticker": ticker, "transactions": result})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Market Sentiment (Fear & Greed + VIX) ─────────
+@app.route("/api/sentiment-market", methods=["POST"])
+def market_sentiment():
+    try:
+        result = {}
+        # Fear & Greed Index
+        try:
+            import fear_and_greed
+            fg = fear_and_greed.get()
+            result["fear_greed"] = {
+                "value": round(fg.value, 1),
+                "description": fg.description,
+            }
+        except Exception as e:
+            result["fear_greed"] = {"value": 50, "description": "Neutral", "error": str(e)}
+
+        # VIX
+        try:
+            import yfinance as yf
+            vix = yf.Ticker("^VIX")
+            vix_hist = vix.history(period="5d")
+            if not vix_hist.empty:
+                vix_close = float(vix_hist["Close"].iloc[-1])
+                result["vix"] = {
+                    "value": round(vix_close, 2),
+                    "label": "Low Volatility" if vix_close < 15 else "Moderate" if vix_close < 25 else "High Volatility" if vix_close < 35 else "Extreme Fear"
+                }
+            else:
+                result["vix"] = {"value": "N/A", "label": "Unavailable"}
+        except Exception as e:
+            result["vix"] = {"value": "N/A", "label": "Unavailable", "error": str(e)}
+
+        return safe_jsonify(result)
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: FRED Economic Indicators ──────────────────────
+@app.route("/api/macro", methods=["POST"])
+def macro_indicators():
+    try:
+        from fredapi import Fred
+        fred = Fred(api_key=FRED_KEY)
+        indicators = {}
+        series_map = {
+            "gdp_growth": ("GDPC1", "GDP (Real, Quarterly)"),
+            "cpi": ("CPIAUCSL", "Consumer Price Index"),
+            "fed_rate": ("FEDFUNDS", "Federal Funds Rate"),
+            "unemployment": ("UNRATE", "Unemployment Rate"),
+            "treasury_2y": ("DGS2", "2-Year Treasury Yield"),
+            "treasury_10y": ("DGS10", "10-Year Treasury Yield"),
+            "treasury_30y": ("DGS30", "30-Year Treasury Yield"),
+        }
+
+        def assess_indicator(key, val):
+            """Returns (status, explanation) — status is 'good', 'bad', or 'neutral'"""
+            if val == "N/A": return "neutral", "Data unavailable."
+            v = float(val)
+            assessments = {
+                "gdp_growth": lambda v: ("good", f"GDP at ${v:,.0f}B indicates a strong economy. Higher GDP means more corporate earnings.") if v > 20000 else ("neutral", f"GDP at ${v:,.0f}B — moderate economic output."),
+                "cpi": lambda v: ("bad", f"CPI at {v:.1f} — inflation is elevated, eroding purchasing power and pressuring the Fed to keep rates high.") if v > 310 else ("good", f"CPI at {v:.1f} — inflation is relatively contained, supportive of lower interest rates."),
+                "fed_rate": lambda v: ("good", f"Fed rate at {v:.2f}% — low rates stimulate borrowing and boost stock valuations.") if v < 2.5 else (("neutral", f"Fed rate at {v:.2f}% — moderate rates balance growth and inflation.") if v < 4.5 else ("bad", f"Fed rate at {v:.2f}% — high rates increase borrowing costs and can weigh on equity valuations.")),
+                "unemployment": lambda v: ("good", f"Unemployment at {v:.1f}% — tight labor market indicates strong economic health.") if v < 4.0 else (("neutral", f"Unemployment at {v:.1f}% — within normal range but rising unemployment could signal slowing growth.") if v < 5.5 else ("bad", f"Unemployment at {v:.1f}% — elevated joblessness signals economic weakness.")),
+                "treasury_2y": lambda v: ("neutral", f"2Y yield at {v:.2f}% — reflects market's short-term rate expectations. Higher yield means tighter policy expected.") if v < 4.5 else ("bad", f"2Y yield at {v:.2f}% — elevated short-term yields signal aggressive monetary tightening."),
+                "treasury_10y": lambda v: ("good", f"10Y yield at {v:.2f}% — low long-term rates are supportive of equity valuations and reduce borrowing costs.") if v < 3.5 else (("neutral", f"10Y yield at {v:.2f}% — moderate levels. Stocks can handle this but it raises cost of capital.") if v < 4.5 else ("bad", f"10Y yield at {v:.2f}% — high yields compete with stocks for investor capital and increase discount rates.")),
+                "treasury_30y": lambda v: ("neutral", f"30Y yield at {v:.2f}% — reflects long-term growth and inflation expectations.") if v < 4.0 else ("bad", f"30Y yield at {v:.2f}% — elevated long-term yields suggest persistent inflation concerns."),
+            }
+            fn = assessments.get(key)
+            if fn: return fn(v)
+            return "neutral", "No assessment available."
+
+        for key, (series_id, label) in series_map.items():
+            try:
+                s = fred.get_series(series_id)
+                latest = s.dropna().iloc[-1]
+                val = round(float(latest), 2)
+                status, explanation = assess_indicator(key, val)
+                indicators[key] = {"value": val, "label": label, "status": status, "explanation": explanation}
+            except:
+                indicators[key] = {"value": "N/A", "label": label, "status": "neutral", "explanation": "Data currently unavailable."}
+
+        return safe_jsonify({"indicators": indicators})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Earnings Calendar (Finnhub) ───────────────────
+@app.route("/api/earnings", methods=["POST"])
+def earnings_calendar():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import requests as req
+        url = f"https://finnhub.io/api/v1/stock/earnings?symbol={ticker}&token={FINNHUB_KEY}"
+        resp = req.get(url, timeout=10).json()
+
+        earnings = []
+        for e in resp[:12]:  # Last 12 quarters
+            earnings.append(sanitize_for_json({
+                "period": e.get("period", ""),
+                "actual": e.get("actual", "N/A"),
+                "estimate": e.get("estimate", "N/A"),
+                "surprise": e.get("surprise", "N/A"),
+                "surprise_pct": e.get("surprisePercent", "N/A"),
+            }))
+
+        return safe_jsonify({"ticker": ticker, "earnings": earnings})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Monte Carlo Simulation ────────────────────────
+@app.route("/api/monte-carlo", methods=["POST"])
+def monte_carlo():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        days = int(data.get("days", 60))
+        simulations = int(data.get("simulations", 1000))
+        prices = data.get("prices", [])
+
+        if len(prices) < 30:
+            return safe_jsonify({"error": "Need at least 30 data points"})
+
+        closes = np.array([p["close"] for p in prices], dtype=float)
+        returns = np.diff(np.log(closes))
+        mu = np.mean(returns)
+        sigma = np.std(returns)
+        last_price = closes[-1]
+
+        # Run simulations
+        np.random.seed(42)
+        all_paths = np.zeros((simulations, days))
+        for i in range(simulations):
+            daily_returns = np.random.normal(mu, sigma, days)
+            price_path = last_price * np.exp(np.cumsum(daily_returns))
+            all_paths[i] = price_path
+
+        # Calculate percentile bands
+        percentiles = {}
+        for p in [10, 25, 50, 75, 90]:
+            band = np.percentile(all_paths, p, axis=0)
+            percentiles[f"p{p}"] = [round(float(v), 2) for v in band]
+
+        final_prices = all_paths[:, -1]
+        return safe_jsonify(sanitize_for_json({
+            "ticker": ticker, "days": days, "simulations": simulations,
+            "start_price": round(float(last_price), 2),
+            "percentiles": percentiles,
+            "final_stats": {
+                "mean": round(float(np.mean(final_prices)), 2),
+                "median": round(float(np.median(final_prices)), 2),
+                "std": round(float(np.std(final_prices)), 2),
+                "p10": round(float(np.percentile(final_prices, 10)), 2),
+                "p90": round(float(np.percentile(final_prices, 90)), 2),
+            }
+        }))
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Altman Z-Score ────────────────────────────────
+@app.route("/api/zscore", methods=["POST"])
+def altman_zscore():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        tk = Toolkit(tickers=[ticker], api_key=FMP_API_KEY)
+        balance = tk.get_balance_sheet_statement()
+        income = tk.get_income_statement()
+
+        ta = get_fin_val(balance, ticker, "Total Assets")
+        tl = get_fin_val(balance, ticker, "Total Liabilities")
+        ca = get_fin_val(balance, ticker, "Total Current Assets")
+        cl = get_fin_val(balance, ticker, "Total Current Liabilities")
+        re = get_fin_val(balance, ticker, "Retained Earnings")
+        ebit = get_fin_val(income, ticker, "Operating Income")
+        revenue = get_fin_val(income, ticker, "Revenue")
+        te = get_fin_val(balance, ticker, "Total Equity")
+
+        if any(v == "N/A" or v == 0 for v in [ta]):
+            return safe_jsonify({"error": "Insufficient data", "ticker": ticker})
+
+        ta, tl = float(ta), float(tl) if tl != "N/A" else 0
+        ca = float(ca) if ca != "N/A" else 0
+        cl = float(cl) if cl != "N/A" else 0
+        re = float(re) if re != "N/A" else 0
+        ebit = float(ebit) if ebit != "N/A" else 0
+        revenue = float(revenue) if revenue != "N/A" else 0
+        te = float(te) if te != "N/A" else 0
+
+        # Get market cap for ratio D
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        market_cap = stock.info.get("marketCap", 0) or 0
+
+        wc = ca - cl
+        A = wc / ta if ta != 0 else 0
+        B = re / ta if ta != 0 else 0
+        C = ebit / ta if ta != 0 else 0
+        D = market_cap / tl if tl != 0 else 0
+        E = revenue / ta if ta != 0 else 0
+
+        z = 1.2 * A + 1.4 * B + 3.3 * C + 0.6 * D + E
+
+        if z > 2.99: zone = "Safe Zone"
+        elif z > 1.81: zone = "Grey Zone"
+        else: zone = "Distress Zone"
+
+        return safe_jsonify(sanitize_for_json({
+            "ticker": ticker, "z_score": round(z, 2), "zone": zone,
+            "components": {
+                "A_working_capital": round(A, 4), "B_retained_earnings": round(B, 4),
+                "C_ebit": round(C, 4), "D_market_cap_debt": round(D, 4),
+                "E_revenue": round(E, 4),
+            }
+        }))
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Dividend Analysis ─────────────────────────────
+@app.route("/api/dividends", methods=["POST"])
+def dividend_analysis():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        dividends = stock.dividends
+
+        div_history = []
+        if dividends is not None and len(dividends) > 0:
+            for date, amount in dividends.tail(20).items():
+                div_history.append({"date": str(date)[:10], "amount": round(float(amount), 4)})
+
+        return safe_jsonify(sanitize_for_json({
+            "ticker": ticker,
+            "dividend_yield": info.get("dividendYield", "N/A"),
+            "dividend_rate": info.get("dividendRate", "N/A"),
+            "payout_ratio": info.get("payoutRatio", "N/A"),
+            "ex_dividend_date": str(info.get("exDividendDate", "N/A")),
+            "five_year_avg_yield": info.get("fiveYearAvgDividendYield", "N/A"),
+            "history": div_history,
+        }))
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Correlation Matrix ────────────────────────────
+@app.route("/api/correlation", methods=["POST"])
+def correlation_matrix():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import yfinance as yf
+
+        benchmarks = ["SPY", "QQQ", "DIA", "GLD", "TLT", "VIX"]
+        all_tickers = [ticker] + [b for b in benchmarks if b.upper() != ticker]
+
+        closes = {}
+        for t in all_tickers:
+            try:
+                sym = f"^{t}" if t == "VIX" else t
+                hist = yf.Ticker(sym).history(period="1y")
+                if not hist.empty:
+                    closes[t] = hist["Close"].pct_change().dropna()
+            except: pass
+
+        if len(closes) < 2:
+            return safe_jsonify({"error": "Not enough data for correlation"})
+
+        df = pd.DataFrame(closes)
+        corr = df.corr()
+
+        matrix = {}
+        for col in corr.columns:
+            matrix[col] = {}
+            for row in corr.index:
+                matrix[col][row] = round(float(corr.loc[row, col]), 3)
+
+        return safe_jsonify({"ticker": ticker, "tickers": list(corr.columns), "matrix": matrix})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Sector Performance Heatmap (Alpha Vantage) ────
+@app.route("/api/heatmap", methods=["POST"])
+def sector_heatmap():
+    try:
+        import requests as req
+        url = f"https://www.alphavantage.co/query?function=SECTOR&apikey={ALPHA_VANTAGE_KEY}"
+        resp = req.get(url, timeout=15).json()
+
+        sectors = {}
+        timeframes = {
+            "1D": "Rank A: Real-Time Performance",
+            "1W": "Rank C: 5 Day Performance",
+            "1M": "Rank D: 1 Month Performance",
+            "3M": "Rank E: 3 Month Performance",
+            "YTD": "Rank F: Year-to-Date (YTD) Performance",
+            "1Y": "Rank G: 1 Year Performance",
+        }
+
+        for tf_key, av_key in timeframes.items():
+            data = resp.get(av_key, {})
+            sectors[tf_key] = {}
+            for sector, pct in data.items():
+                try:
+                    sectors[tf_key][sector] = float(pct.replace("%", ""))
+                except:
+                    sectors[tf_key][sector] = 0
+
+        return safe_jsonify({"sectors": sectors, "timeframes": list(timeframes.keys())})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Currency Conversion Rates ─────────────────────
+@app.route("/api/currency", methods=["POST"])
+def currency_rates():
+    """Return conversion rates from USD to GBP/INR so the frontend can convert all values."""
+    try:
+        import requests as req
+        url = f"https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency=USD&to_currency=GBP&apikey={ALPHA_VANTAGE_KEY}"
+        resp = req.get(url, timeout=10).json()
+        usd_gbp = float(resp.get("Realtime Currency Exchange Rate", {}).get("5. Exchange Rate", 0.79))
+    except:
+        usd_gbp = 0.79  # Fallback
+    try:
+        import requests as req
+        url = f"https://www.alphavantage.co/query?function=CURRENCY_EXCHANGE_RATE&from_currency=USD&to_currency=INR&apikey={ALPHA_VANTAGE_KEY}"
+        resp = req.get(url, timeout=10).json()
+        usd_inr = float(resp.get("Realtime Currency Exchange Rate", {}).get("5. Exchange Rate", 83.5))
+    except:
+        usd_inr = 83.5
+    return safe_jsonify({"USD": 1.0, "GBP": usd_gbp, "INR": usd_inr})
+
+# ── Route: Options Chain (with Greeks) ───────────────────
+@app.route("/api/options/chain", methods=["POST"])
+def options_chain():
+    """Fetch options chain data with calculated Greeks."""
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import yfinance as yf
+        from options_engine import enrich_chain_with_greeks
+        stock = yf.Ticker(ticker)
+        expirations = stock.options
+        if not expirations:
+            return safe_jsonify({"error": f"No options data available for {ticker}", "available": False})
+
+        exp = data.get("expiration", expirations[0])
+        if exp not in expirations:
+            exp = expirations[0]
+
+        chain = stock.option_chain(exp)
+        calls = chain.calls.fillna(0).to_dict(orient="records")
+        puts = chain.puts.fillna(0).to_dict(orient="records")
+
+        # Clean up timestamps
+        for row in calls + puts:
+            for k, v in row.items():
+                if hasattr(v, 'isoformat'):
+                    row[k] = str(v)
+
+        info = stock.info
+        current_price = info.get("regularMarketPrice") or info.get("previousClose", 0)
+
+        # Enrich with Greeks
+        for c in calls: c["_type"] = "call"
+        for p in puts: p["_type"] = "put"
+        calls = enrich_chain_with_greeks(calls, current_price, exp)
+        puts = enrich_chain_with_greeks(puts, current_price, exp)
+
+        return safe_jsonify({
+            "ticker": ticker,
+            "current_price": current_price,
+            "expiration": exp,
+            "expirations": list(expirations),
+            "calls": calls[:50],
+            "puts": puts[:50],
+            "call_count": len(calls),
+            "put_count": len(puts),
+        })
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Futures Data ──────────────────────────────────
+@app.route("/api/futures", methods=["POST"])
+def futures_data():
+    """Fetch futures contract data via yfinance."""
+    try:
+        data = request.json
+        ticker = data.get("ticker", "ES=F").upper().strip()
+        import yfinance as yf
+        fut = yf.Ticker(ticker)
+        info = fut.info
+
+        # Historical data
+        hist = fut.history(period="6mo")
+        price_history = []
+        for date, row in hist.iterrows():
+            price_history.append({
+                "date": date.strftime("%Y-%m-%d"),
+                "open": round(row["Open"], 2),
+                "high": round(row["High"], 2),
+                "low": round(row["Low"], 2),
+                "close": round(row["Close"], 2),
+                "volume": int(row.get("Volume", 0)),
+            })
+
+        return safe_jsonify({
+            "ticker": ticker,
+            "name": info.get("shortName", ticker),
+            "price": info.get("regularMarketPrice") or info.get("previousClose", 0),
+            "change": info.get("regularMarketChange", 0),
+            "change_pct": info.get("regularMarketChangePercent", 0),
+            "day_high": info.get("regularMarketDayHigh", 0),
+            "day_low": info.get("regularMarketDayLow", 0),
+            "open_interest": info.get("openInterest", "N/A"),
+            "volume": info.get("regularMarketVolume", 0),
+            "prev_close": info.get("regularMarketPreviousClose", 0),
+            "price_history": price_history,
+        })
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Forex Pair Data ───────────────────────────────
+@app.route("/api/forex", methods=["POST"])
+def forex_data():
+    """Fetch forex pair data via yfinance."""
+    try:
+        data = request.json
+        pair = data.get("pair", "EURUSD=X").upper().strip()
+        import yfinance as yf
+        fx = yf.Ticker(pair)
+        info = fx.info
+
+        hist = fx.history(period="6mo")
+        price_history = []
+        for date, row in hist.iterrows():
+            price_history.append({
+                "date": date.strftime("%Y-%m-%d"),
+                "open": round(row["Open"], 6),
+                "high": round(row["High"], 6),
+                "low": round(row["Low"], 6),
+                "close": round(row["Close"], 6),
+                "volume": int(row.get("Volume", 0)),
+            })
+
+        return safe_jsonify({
+            "pair": pair,
+            "name": info.get("shortName", pair),
+            "rate": info.get("regularMarketPrice") or info.get("previousClose", 0),
+            "change": info.get("regularMarketChange", 0),
+            "change_pct": info.get("regularMarketChangePercent", 0),
+            "day_high": info.get("regularMarketDayHigh", 0),
+            "day_low": info.get("regularMarketDayLow", 0),
+            "bid": info.get("bid", 0),
+            "ask": info.get("ask", 0),
+            "price_history": price_history,
+        })
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Live Price (for auto-refresh) ─────────────────
+@app.route("/api/live-price", methods=["POST"])
+def live_price():
+    """Quick price fetch for auto-refresh polling."""
+    try:
+        data = request.json
+        ticker = data.get("ticker", "AAPL").upper().strip()
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        return safe_jsonify({
+            "ticker": ticker,
+            "price": info.get("regularMarketPrice") or info.get("previousClose", 0),
+            "change": info.get("regularMarketChange", 0),
+            "change_pct": info.get("regularMarketChangePercent", 0),
+            "volume": info.get("regularMarketVolume", 0),
+            "timestamp": datetime.now().isoformat(),
+        })
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Options Payoff Diagram ─────────────────────
+@app.route("/api/options/payoff", methods=["POST"])
+def options_payoff():
+    try:
+        from options_engine import payoff_diagram
+        data = request.json
+        K = float(data.get("strike", 100))
+        premium = float(data.get("premium", 5))
+        opt_type = data.get("option_type", "call")
+        is_long = data.get("is_long", True)
+        S = float(data.get("current_price", K))
+        points = payoff_diagram(S, K, premium, opt_type, is_long)
+        return safe_jsonify({"points": points, "strike": K, "premium": premium, "type": opt_type, "direction": "long" if is_long else "short"})
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Portfolio ──────────────────────────────────
+import portfolio_engine
+
+def _fetch_live_prices(tickers):
+    """Helper: fetch live prices for a list of tickers."""
+    import yfinance as yf
+    prices = {}
+    for t in tickers:
+        try:
+            stock = yf.Ticker(t)
+            info = stock.info
+            prices[t] = info.get("regularMarketPrice") or info.get("previousClose", 0)
+        except:
+            pass
+    return prices
+
+@app.route("/api/portfolio", methods=["GET"])
+def get_portfolio():
+    """Get current portfolio with live prices."""
+    try:
+        positions = portfolio_engine.get_positions()
+        current_prices = _fetch_live_prices([p["ticker"] for p in positions])
+        summary = portfolio_engine.get_portfolio_summary(current_prices)
+        # Record equity point and daily snapshot
+        portfolio_engine.record_equity_point(summary["total_value"], summary["cash"], summary["positions_value"])
+        portfolio_engine.save_daily_snapshot(summary["total_value"], summary["cash"], summary["positions_value"])
+        # Check pending orders
+        filled = portfolio_engine.check_and_fill_orders(current_prices)
+        summary["filled_orders"] = filled
+        summary["pending_orders"] = portfolio_engine.get_pending_orders()
+        return safe_jsonify(summary)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/buy", methods=["POST"])
+def portfolio_buy():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "").upper().strip()
+        shares = float(data.get("shares", 0))
+        asset_type = data.get("asset_type", "stock")
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        price = info.get("regularMarketPrice") or info.get("previousClose", 0)
+        if price <= 0:
+            return safe_jsonify({"error": f"Cannot get price for {ticker}"}), 400
+        result = portfolio_engine.buy(ticker, shares, price, asset_type)
+        if "error" in result:
+            return safe_jsonify(result), 400
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/sell", methods=["POST"])
+def portfolio_sell():
+    try:
+        data = request.json
+        ticker = data.get("ticker", "").upper().strip()
+        shares = float(data.get("shares", 0))
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        price = info.get("regularMarketPrice") or info.get("previousClose", 0)
+        if price <= 0:
+            return safe_jsonify({"error": f"Cannot get price for {ticker}"}), 400
+        result = portfolio_engine.sell(ticker, shares, price)
+        if "error" in result:
+            return safe_jsonify(result), 400
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/short", methods=["POST"])
+def portfolio_short():
+    """Open a short position."""
+    try:
+        data = request.json
+        ticker = data.get("ticker", "").upper().strip()
+        shares = float(data.get("shares", 0))
+        asset_type = data.get("asset_type", "stock")
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        price = info.get("regularMarketPrice") or info.get("previousClose", 0)
+        if price <= 0:
+            return safe_jsonify({"error": f"Cannot get price for {ticker}"}), 400
+        result = portfolio_engine.short_sell(ticker, shares, price, asset_type)
+        if "error" in result:
+            return safe_jsonify(result), 400
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/cover", methods=["POST"])
+def portfolio_cover():
+    """Cover (close) a short position."""
+    try:
+        data = request.json
+        ticker = data.get("ticker", "").upper().strip()
+        shares = float(data.get("shares", 0))
+        import yfinance as yf
+        stock = yf.Ticker(ticker)
+        info = stock.info
+        price = info.get("regularMarketPrice") or info.get("previousClose", 0)
+        if price <= 0:
+            return safe_jsonify({"error": f"Cannot get price for {ticker}"}), 400
+        result = portfolio_engine.cover_short(ticker, shares, price)
+        if "error" in result:
+            return safe_jsonify(result), 400
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/limit-order", methods=["POST"])
+def portfolio_limit_order():
+    """Place a limit order."""
+    try:
+        data = request.json
+        result = portfolio_engine.place_limit_order(
+            ticker=data.get("ticker", "").upper().strip(),
+            side=data.get("side", "BUY").upper(),
+            shares=float(data.get("shares", 0)),
+            limit_price=float(data.get("price", 0)),
+            asset_type=data.get("asset_type", "stock"),
+        )
+        if "error" in result:
+            return safe_jsonify(result), 400
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/stop-order", methods=["POST"])
+def portfolio_stop_order():
+    """Place a stop order (stop-loss / take-profit)."""
+    try:
+        data = request.json
+        result = portfolio_engine.place_stop_order(
+            ticker=data.get("ticker", "").upper().strip(),
+            side=data.get("side", "SELL").upper(),
+            shares=float(data.get("shares", 0)),
+            stop_price=float(data.get("price", 0)),
+            asset_type=data.get("asset_type", "stock"),
+        )
+        if "error" in result:
+            return safe_jsonify(result), 400
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/orders", methods=["GET"])
+def portfolio_orders():
+    """Get pending orders."""
+    try:
+        return safe_jsonify({"orders": portfolio_engine.get_pending_orders()})
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/cancel-order", methods=["POST"])
+def portfolio_cancel_order():
+    """Cancel a pending order."""
+    try:
+        data = request.json
+        order_id = int(data.get("order_id", 0))
+        return safe_jsonify(portfolio_engine.cancel_order(order_id))
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/equity-curve", methods=["GET"])
+def portfolio_equity_curve():
+    """Get equity curve for charting."""
+    try:
+        return safe_jsonify({"curve": portfolio_engine.get_equity_curve()})
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/history", methods=["GET"])
+def portfolio_history():
+    try:
+        return safe_jsonify({"transactions": portfolio_engine.get_transactions()})
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/analytics", methods=["GET"])
+def portfolio_analytics():
+    try:
+        positions = portfolio_engine.get_positions()
+        current_prices = _fetch_live_prices([p["ticker"] for p in positions])
+        return safe_jsonify(portfolio_engine.get_analytics(current_prices))
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+@app.route("/api/portfolio/reset", methods=["POST"])
+def portfolio_reset():
+    try:
+        return safe_jsonify(portfolio_engine.reset_portfolio())
+    except Exception as e:
+        return safe_jsonify({"error": str(e)}), 500
+
+# ── Route: Market Summary (Dashboard) ────────────────
+_market_cache = {"data": None, "ts": 0}
+
+@app.route("/api/market-summary", methods=["GET"])
+def market_summary():
+    """Global market snapshot for the dashboard landing page."""
+    import time
+    now = time.time()
+    # 5-minute cache
+    if _market_cache["data"] and (now - _market_cache["ts"]) < 300:
+        return safe_jsonify(_market_cache["data"])
+
+    try:
+        import yfinance as yf
+
+        symbols = {
+            "indices": [
+                ("^NSEI", "NIFTY 50"), ("^BSESN", "SENSEX"),
+                ("^GSPC", "S&P 500"), ("^IXIC", "NASDAQ"),
+                ("^FTSE", "FTSE 100"), ("^N225", "Nikkei 225"),
+            ],
+            "commodities": [
+                ("GC=F", "Gold"), ("SI=F", "Silver"),
+                ("CL=F", "Crude Oil WTI"), ("NG=F", "Natural Gas"),
+            ],
+            "currencies": [
+                ("EURUSD=X", "EUR/USD"), ("GBPUSD=X", "GBP/USD"),
+                ("USDJPY=X", "USD/JPY"), ("USDINR=X", "USD/INR"),
+            ],
+        }
+
+        result = {}
+        for category, items in symbols.items():
+            cat_list = []
+            tickers_str = " ".join([s[0] for s in items])
+            try:
+                data = yf.download(tickers_str, period="2d", group_by="ticker", progress=False)
+                for sym, name in items:
+                    try:
+                        if len(items) == 1:
+                            df = data
+                        else:
+                            df = data[sym] if sym in data.columns.get_level_values(0) else None
+
+                        if df is not None and len(df) >= 1:
+                            latest = df.iloc[-1]
+                            prev = df.iloc[-2] if len(df) >= 2 else df.iloc[-1]
+                            price = float(latest["Close"])
+                            prev_close = float(prev["Close"])
+                            change = price - prev_close
+                            change_pct = (change / prev_close * 100) if prev_close else 0
+                            cat_list.append({
+                                "symbol": sym, "name": name,
+                                "price": round(price, 2),
+                                "change": round(change, 2),
+                                "change_pct": round(change_pct, 2),
+                            })
+                        else:
+                            cat_list.append({"symbol": sym, "name": name, "price": 0, "change": 0, "change_pct": 0})
+                    except Exception:
+                        cat_list.append({"symbol": sym, "name": name, "price": 0, "change": 0, "change_pct": 0})
+            except Exception:
+                for sym, name in items:
+                    cat_list.append({"symbol": sym, "name": name, "price": 0, "change": 0, "change_pct": 0})
+            result[category] = cat_list
+
+        _market_cache["data"] = result
+        _market_cache["ts"] = now
+        return safe_jsonify(result)
+    except Exception as e:
+        traceback.print_exc()
+        return safe_jsonify({"error": str(e)}), 500
+
+if __name__ == "__main__":
+    import socket
+    hostname = socket.gethostname()
+    local_ip = socket.gethostbyname(hostname)
+    print(f"\n  FinanceIQ v5.2")
+    print(f"  Local:   http://localhost:5000")
+    print(f"  Network: http://{local_ip}:5000\n")
+    app.run(debug=True, port=5000, host="0.0.0.0")
+
diff --git a/backtester.py b/backtester.py
new file mode 100644
index 0000000..783fdf7
--- /dev/null
+++ b/backtester.py
@@ -0,0 +1,177 @@
+"""
+Backtesting Engine - Phase 7 (Bi-Directional Market Neutral)
+Profits from both rising and falling markets.
+Logic:
+1. Long: Price > EMA 5
+2. Short: Price < EMA 5
+3. Hedge: If BB Width > 5% (High Volatility), hold both to stay neutral.
+"""
+import pandas as pd
+import numpy as np
+from financetoolkit import Toolkit
+import sys
+
+# Constants
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+TICKERS = ["^NSEBANK", "NVDA", "TSLA"]
+MONTHLY_BUDGET = 300.0
+
+def fetch_portfolio_data():
+    """Fetches 1 year of historical data with technicals."""
+    print(f"--- Fetching 1 Year Data for {TICKERS} ---")
+    try:
+        companies = Toolkit(
+            tickers=TICKERS,
+            api_key=API_KEY,
+            start_date="2024-01-01", 
+        )
+        historical = companies.get_historical_data(period="daily")
+        
+        portfolio = {}
+        for ticker in TICKERS:
+            if ticker in historical.columns.get_level_values(1):
+                df = historical.xs(ticker, level=1, axis=1).copy()
+            elif ticker in historical.columns.get_level_values(0):
+                df = historical.xs(ticker, level=0, axis=1).copy()
+            else: continue
+                
+            # Technicals for signals
+            df['EMA_5'] = df['Close'].ewm(span=5, adjust=False).mean()
+            # Bollinger Band Width
+            std_20 = df['Close'].rolling(window=20).std()
+            ma_20 = df['Close'].rolling(window=20).mean()
+            df['BB_Width'] = (4 * std_20) / ma_20
+            
+            df.dropna(inplace=True)
+            portfolio[ticker] = df
+            
+        return portfolio
+    except Exception as e:
+        print(f"Error fetching data: {e}")
+        return {}
+
+def simulate_market_neutral(data, ticker):
+    """
+    Simulates Bi-Directional strategy.
+    Can be Long, Short, or Hedged.
+    """
+    cash = 0
+    long_holdings = 0
+    short_holdings = 0
+    short_entry_price = 0
+    
+    total_invested = 0
+    budget_per_month = MONTHLY_BUDGET / len(TICKERS)
+    
+    day_count = 0
+    for date, row in data.iterrows():
+        day_count += 1
+        price = row['Close']
+        
+        # Monthly Injection
+        if day_count % 20 == 0:
+            cash += budget_per_month
+            total_invested += budget_per_month
+            
+        # 1. EXIT CURRENT POSITIONS IF SIGNAL CHANGES
+        # (Simplified: check daily if we should switch)
+        
+        signal = "NEUTRAL"
+        if row['BB_Width'] > 0.08: # Hedge if high volatility (>8% width)
+            signal = "HEDGE"
+        elif price > row['EMA_5']:
+            signal = "LONG"
+        else:
+            signal = "SHORT"
+            
+        # 2. EXECUTE
+        if signal == "LONG":
+            # Close Short if any
+            if short_holdings > 0:
+                profit = (short_entry_price - price) * short_holdings
+                cash += (short_holdings * short_entry_price) + profit
+                short_holdings = 0
+            # Open Long
+            if cash > 10:
+                long_holdings += cash / price
+                cash = 0
+                
+        elif signal == "SHORT":
+            # Close Long if any
+            if long_holdings > 0:
+                cash += long_holdings * price
+                long_holdings = 0
+            # Open Short
+            if cash > 10:
+                short_holdings = cash / price
+                short_entry_price = price
+                cash = 0
+                
+        elif signal == "HEDGE":
+            # Split 50/50
+            current_val = cash + (long_holdings * price) + (short_holdings * price if short_holdings > 0 else 0)
+            # Flatten everything first for simplicity in simulation
+            if short_holdings > 0:
+                profit = (short_entry_price - price) * short_holdings
+                current_val += profit # Adjust for short profit/loss
+            
+            cash = current_val
+            long_holdings = (cash * 0.5) / price
+            short_holdings = (cash * 0.5) / price
+            short_entry_price = price
+            cash = 0
+
+    # Final Liquidation
+    final_price = data.iloc[-1]['Close']
+    short_profit = (short_entry_price - final_price) * short_holdings if short_holdings > 0 else 0
+    final_val = cash + (long_holdings * final_price) + (short_holdings * short_entry_price) + short_profit
+    
+    profit = final_val - total_invested
+    roi = profit / total_invested if total_invested > 0 else 0
+    
+    # Bench
+    start = data.iloc[0]['Close']
+    end = data.iloc[-1]['Close']
+    bench_roi = (end / start) - 1
+    
+    return {
+        'ticker': ticker,
+        'final_val': final_val,
+        'invested': total_invested,
+        'roi': roi * 100,
+        'bench_roi': bench_roi * 100
+    }
+
+def main():
+    portfolio = fetch_portfolio_data()
+    if not portfolio: return
+
+    print("\n--- Running Phase 7 Backtest (Bi-Directional Long/Short) ---")
+    results = []
+    
+    for ticker, df in portfolio.items():
+        res = simulate_market_neutral(df, ticker)
+        results.append(res)
+        
+    print("\n" + "="*60)
+    print(f"{'Ticker':<10} | {'Strategy ROI':<15} | {'Bench ROI':<10}")
+    print("-" * 60)
+    
+    total_invested = 0
+    total_final = 0
+    
+    for r in results:
+        print(f"{r['ticker']:<10} | {r['roi']:>14.2f}% | {r['bench_roi']:>9.2f}%")
+        total_invested += r['invested']
+        total_final += r['final_val']
+        
+    final_roi = ((total_final - total_invested) / total_invested) * 100 if total_invested > 0 else 0
+    
+    print("-" * 60)
+    print(f"{'TOTAL':<10} | {final_roi:>14.2f}% | {'---':>9}")
+    print("="*60)
+    
+    print("\nNote: ROI includes profits from both price gains (Long) and price drops (Short).")
+
+if __name__ == "__main__":
+    main()
diff --git a/news_analyzer.py b/news_analyzer.py
new file mode 100644
index 0000000..05148e2
--- /dev/null
+++ b/news_analyzer.py
@@ -0,0 +1,101 @@
+"""
+Module for fetching financial news via Google News RSS and analyzing sentiment using VADER.
+"""
+import feedparser
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+from datetime import datetime
+import time
+
+def fetch_news(ticker, limit=5):
+    """
+    Fetches the latest news for a given ticker from Google News RSS.
+    
+    Args:
+        ticker (str): Stock ticker symbol (e.g., 'AAPL', 'NVDA', 'RELIANCE.NS').
+        limit (int): Maximum number of news items to return.
+        
+    Returns:
+        list: A list of dictionaries containing 'title', 'link', 'published', and 'summary'.
+    """
+    # Use standard Google News RSS search query
+    # "when:1d" parameter ensures recent news if supported, but RSS feed order is usually chronological
+    encoded_ticker = ticker.replace("&", "%26")
+    rss_url = f"https://news.google.com/rss/search?q={encoded_ticker}+stock+when:1d&hl=en-US&gl=US&ceid=US:en"
+    
+    try:
+        feed = feedparser.parse(rss_url)
+        news_items = []
+        
+        for entry in feed.entries[:limit]:
+            news_items.append({
+                'title': entry.title,
+                'link': entry.link,
+                'published': entry.get('published', datetime.now().strftime("%a, %d %b %Y %H:%M:%S GMT")),
+                'summary': entry.get('description', '')
+            })
+            
+        return news_items
+    except Exception as e:
+        print(f"Error fetching news for {ticker}: {e}")
+        return []
+
+def analyze_sentiment(news_items):
+    """
+    Analyzes the sentiment of a list of news items.
+    
+    Args:
+        news_items (list): List of news dictionaries.
+        
+    Returns:
+        dict: Contains 'average_score', 'sentiment_label', and 'scored_news'.
+    """
+    analyzer = SentimentIntensityAnalyzer()
+    total_score = 0
+    scored_news = []
+    
+    if not news_items:
+        return {
+            'average_score': 0,
+            'sentiment_label': 'Neutral',
+            'scored_news': []
+        }
+        
+    for item in news_items:
+        # Analyze title mostly as it contains the key info in RSS
+        text_to_analyze = f"{item['title']}. {item['summary']}"
+        sentiment = analyzer.polarity_scores(text_to_analyze)
+        compound_score = sentiment['compound']
+        
+        total_score += compound_score
+        
+        item_with_score = item.copy()
+        item_with_score['sentiment_score'] = compound_score
+        scored_news.append(item_with_score)
+        
+    average_score = total_score / len(news_items)
+    
+    if average_score >= 0.05:
+        label = "Positive"
+    elif average_score <= -0.05:
+        label = "Negative"
+    else:
+        label = "Neutral"
+        
+    return {
+        'average_score': round(average_score, 4),
+        'sentiment_label': label,
+        'scored_news': scored_news
+    }
+
+if __name__ == "__main__":
+    # Test Block
+    ticker = "AAPL"
+    print(f"--- Fetching News for {ticker} ---")
+    news = fetch_news(ticker)
+    for n in news:
+        print(f"- {n['title']}")
+        
+    print(f"\n--- Analyzing Sentiment ---")
+    result = analyze_sentiment(news)
+    print(f"Average Score: {result['average_score']}")
+    print(f"Label: {result['sentiment_label']}")
diff --git a/options_engine.py b/options_engine.py
new file mode 100644
index 0000000..c50b3c5
--- /dev/null
+++ b/options_engine.py
@@ -0,0 +1,185 @@
+"""
+FinanceIQ v5.1 — Options Analytics Engine
+Black-Scholes pricing, Greeks, implied volatility, and payoff diagrams.
+"""
+import math
+from scipy.stats import norm
+
+
+def d1(S, K, T, r, sigma):
+    """Calculate d1 for Black-Scholes."""
+    if T <= 0 or sigma <= 0:
+        return 0.0
+    return (math.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * math.sqrt(T))
+
+
+def d2(S, K, T, r, sigma):
+    """Calculate d2 for Black-Scholes."""
+    return d1(S, K, T, r, sigma) - sigma * math.sqrt(T) if T > 0 and sigma > 0 else 0.0
+
+
+def bs_call_price(S, K, T, r, sigma):
+    """Black-Scholes call option price."""
+    if T <= 0:
+        return max(S - K, 0)
+    _d1 = d1(S, K, T, r, sigma)
+    _d2 = d2(S, K, T, r, sigma)
+    return S * norm.cdf(_d1) - K * math.exp(-r * T) * norm.cdf(_d2)
+
+
+def bs_put_price(S, K, T, r, sigma):
+    """Black-Scholes put option price."""
+    if T <= 0:
+        return max(K - S, 0)
+    _d1 = d1(S, K, T, r, sigma)
+    _d2 = d2(S, K, T, r, sigma)
+    return K * math.exp(-r * T) * norm.cdf(-_d2) - S * norm.cdf(-_d1)
+
+
+def calculate_greeks(S, K, T, r, sigma, option_type="call"):
+    """
+    Calculate all Greeks for an option.
+    S: underlying price, K: strike, T: time to expiry (years),
+    r: risk-free rate, sigma: implied volatility
+    """
+    if T <= 0 or sigma <= 0:
+        intrinsic = max(S - K, 0) if option_type == "call" else max(K - S, 0)
+        return {
+            "delta": 1.0 if (option_type == "call" and S > K) else (-1.0 if option_type == "put" and K > S else 0.0),
+            "gamma": 0.0,
+            "theta": 0.0,
+            "vega": 0.0,
+            "rho": 0.0,
+            "price": intrinsic
+        }
+
+    _d1 = d1(S, K, T, r, sigma)
+    _d2 = d2(S, K, T, r, sigma)
+    sqrt_T = math.sqrt(T)
+
+    # Delta
+    delta = norm.cdf(_d1) if option_type == "call" else norm.cdf(_d1) - 1
+
+    # Gamma (same for calls & puts)
+    gamma = norm.pdf(_d1) / (S * sigma * sqrt_T)
+
+    # Theta (per day)
+    theta_common = -(S * norm.pdf(_d1) * sigma) / (2 * sqrt_T)
+    if option_type == "call":
+        theta = (theta_common - r * K * math.exp(-r * T) * norm.cdf(_d2)) / 365
+    else:
+        theta = (theta_common + r * K * math.exp(-r * T) * norm.cdf(-_d2)) / 365
+
+    # Vega (per 1% move in IV)
+    vega = S * sqrt_T * norm.pdf(_d1) / 100
+
+    # Rho (per 1% move in rate)
+    if option_type == "call":
+        rho = K * T * math.exp(-r * T) * norm.cdf(_d2) / 100
+    else:
+        rho = -K * T * math.exp(-r * T) * norm.cdf(-_d2) / 100
+
+    # Price
+    price = bs_call_price(S, K, T, r, sigma) if option_type == "call" else bs_put_price(S, K, T, r, sigma)
+
+    return {
+        "delta": round(delta, 4),
+        "gamma": round(gamma, 6),
+        "theta": round(theta, 4),
+        "vega": round(vega, 4),
+        "rho": round(rho, 4),
+        "price": round(price, 2)
+    }
+
+
+def implied_volatility(market_price, S, K, T, r, option_type="call", tol=1e-6, max_iter=100):
+    """
+    Calculate implied volatility using Newton-Raphson method.
+    """
+    if T <= 0 or market_price <= 0:
+        return 0.0
+
+    sigma = 0.3  # initial guess
+    for _ in range(max_iter):
+        if option_type == "call":
+            price = bs_call_price(S, K, T, r, sigma)
+        else:
+            price = bs_put_price(S, K, T, r, sigma)
+
+        diff = price - market_price
+        if abs(diff) < tol:
+            return round(sigma, 6)
+
+        # Vega for Newton-Raphson step
+        _d1 = d1(S, K, T, r, sigma)
+        vega = S * math.sqrt(T) * norm.pdf(_d1)
+        if vega < 1e-12:
+            break
+        sigma -= diff / vega
+        sigma = max(sigma, 0.001)  # floor
+
+    return round(sigma, 6)
+
+
+def payoff_diagram(S, K, premium, option_type="call", is_long=True, num_points=50):
+    """
+    Generate payoff diagram data points.
+    Returns list of {price, payoff, profit} dicts.
+    """
+    low = K * 0.7
+    high = K * 1.3
+    step = (high - low) / num_points
+    points = []
+    for i in range(num_points + 1):
+        price = low + i * step
+        if option_type == "call":
+            payoff = max(price - K, 0)
+        else:
+            payoff = max(K - price, 0)
+
+        if is_long:
+            profit = payoff - premium
+        else:
+            profit = premium - payoff
+
+        points.append({
+            "price": round(price, 2),
+            "payoff": round(payoff, 2),
+            "profit": round(profit, 2)
+        })
+    return points
+
+
+def enrich_chain_with_greeks(chain_data, current_price, expiry_date_str, risk_free_rate=0.05):
+    """
+    Add Greeks to each option in a chain.
+    chain_data: list of dicts from yfinance option_chain
+    expiry_date_str: 'YYYY-MM-DD'
+    """
+    from datetime import datetime
+    try:
+        expiry = datetime.strptime(expiry_date_str, "%Y-%m-%d")
+        today = datetime.now()
+        T = max((expiry - today).days / 365.0, 0.001)
+    except:
+        T = 0.1  # fallback
+
+    for opt in chain_data:
+        strike = opt.get("strike", 0)
+        last_price = opt.get("lastPrice", 0)
+        iv = opt.get("impliedVolatility", 0.3)
+        opt_type = "call" if opt.get("_type", "call") == "call" else "put"
+
+        if strike > 0 and current_price > 0 and iv > 0:
+            greeks = calculate_greeks(current_price, strike, T, risk_free_rate, iv, opt_type)
+            opt["delta"] = greeks["delta"]
+            opt["gamma"] = greeks["gamma"]
+            opt["theta"] = greeks["theta"]
+            opt["vega"] = greeks["vega"]
+            opt["rho"] = greeks["rho"]
+            opt["bs_price"] = greeks["price"]
+        else:
+            opt["delta"] = opt["gamma"] = opt["theta"] = opt["vega"] = opt["rho"] = 0
+            opt["bs_price"] = 0
+
+    return chain_data
diff --git a/portfolio_engine.py b/portfolio_engine.py
new file mode 100644
index 0000000..96e0457
--- /dev/null
+++ b/portfolio_engine.py
@@ -0,0 +1,741 @@
+"""
+FinanceIQ v5.2 — Enhanced Paper Trading Portfolio Engine
+SQLite-backed virtual portfolio with $100K starting capital.
+
+Features inspired by hftbacktest:
+  - Market, Limit, Stop-Loss, Take-Profit orders
+  - Slippage & commission modeling
+  - Short selling with margin tracking
+  - Equity curve tracking
+  - Enhanced analytics (Sortino, Calmar, profit factor, avg hold period)
+"""
+import sqlite3
+import os
+import math
+from datetime import datetime
+
+DB_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "portfolio.db")
+INITIAL_CASH = 100000.00
+DEFAULT_SLIPPAGE_BPS = 5      # 0.05% default slippage
+DEFAULT_COMMISSION_PER_SHARE = 0.005  # $0.005 per share (IBKR-style)
+MIN_COMMISSION = 1.00          # $1 minimum per trade
+
+
+def get_db():
+    """Get database connection and ensure tables exist."""
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS portfolio_meta (
+            id INTEGER PRIMARY KEY CHECK (id = 1),
+            cash REAL NOT NULL DEFAULT 100000.00,
+            slippage_bps REAL NOT NULL DEFAULT 5,
+            commission_per_share REAL NOT NULL DEFAULT 0.005,
+            margin_used REAL NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS positions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ticker TEXT NOT NULL,
+            asset_type TEXT NOT NULL DEFAULT 'stock',
+            shares REAL NOT NULL DEFAULT 0,
+            avg_cost REAL NOT NULL DEFAULT 0,
+            side TEXT NOT NULL DEFAULT 'LONG',
+            opened_at TEXT NOT NULL DEFAULT (datetime('now')),
+            updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+            UNIQUE(ticker, side)
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS transactions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ticker TEXT NOT NULL,
+            asset_type TEXT NOT NULL DEFAULT 'stock',
+            action TEXT NOT NULL,
+            side TEXT NOT NULL DEFAULT 'LONG',
+            shares REAL NOT NULL,
+            price REAL NOT NULL,
+            slippage REAL NOT NULL DEFAULT 0,
+            commission REAL NOT NULL DEFAULT 0,
+            total REAL NOT NULL,
+            pnl REAL DEFAULT NULL,
+            timestamp TEXT NOT NULL DEFAULT (datetime('now'))
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS pending_orders (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            ticker TEXT NOT NULL,
+            asset_type TEXT NOT NULL DEFAULT 'stock',
+            order_type TEXT NOT NULL,
+            side TEXT NOT NULL DEFAULT 'BUY',
+            shares REAL NOT NULL,
+            target_price REAL NOT NULL,
+            status TEXT NOT NULL DEFAULT 'PENDING',
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            filled_at TEXT DEFAULT NULL,
+            expires_at TEXT DEFAULT NULL
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS equity_curve (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            timestamp TEXT NOT NULL,
+            total_value REAL NOT NULL,
+            cash REAL NOT NULL,
+            positions_value REAL NOT NULL,
+            daily_return REAL DEFAULT 0
+        )
+    """)
+    conn.execute("""
+        CREATE TABLE IF NOT EXISTS portfolio_snapshots (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            date TEXT NOT NULL UNIQUE,
+            total_value REAL NOT NULL,
+            cash REAL NOT NULL,
+            positions_value REAL NOT NULL
+        )
+    """)
+
+    cursor = conn.execute("SELECT COUNT(*) FROM portfolio_meta")
+    if cursor.fetchone()[0] == 0:
+        conn.execute("INSERT INTO portfolio_meta (id, cash) VALUES (1, ?)", (INITIAL_CASH,))
+    conn.commit()
+    return conn
+
+
+def _get_meta(conn):
+    row = conn.execute("SELECT * FROM portfolio_meta WHERE id = 1").fetchone()
+    return dict(row)
+
+
+def _calc_slippage(price, shares, slippage_bps, side):
+    """Calculate slippage based on order direction."""
+    slip_pct = slippage_bps / 10000.0
+    if side == "BUY":
+        return price * slip_pct  # pay more when buying
+    else:
+        return -price * slip_pct  # receive less when selling
+
+
+def _calc_commission(shares, comm_per_share):
+    """Calculate commission with minimum."""
+    return max(abs(shares) * comm_per_share, MIN_COMMISSION)
+
+
+def get_cash():
+    conn = get_db()
+    row = conn.execute("SELECT cash FROM portfolio_meta WHERE id = 1").fetchone()
+    conn.close()
+    return row["cash"] if row else INITIAL_CASH
+
+
+def get_positions():
+    conn = get_db()
+    rows = conn.execute("SELECT * FROM positions WHERE shares > 0").fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def buy(ticker, shares, price, asset_type="stock"):
+    """Buy shares (long) with slippage and commission."""
+    if shares <= 0 or price <= 0:
+        return {"error": "Invalid shares or price"}
+
+    conn = get_db()
+    meta = _get_meta(conn)
+    cash = meta["cash"]
+    slippage_bps = meta["slippage_bps"]
+    comm_per_share = meta["commission_per_share"]
+
+    # Apply slippage
+    slip = _calc_slippage(price, shares, slippage_bps, "BUY")
+    exec_price = price + slip
+
+    # Calculate commission
+    commission = _calc_commission(shares, comm_per_share)
+
+    total_cost = shares * exec_price + commission
+
+    if total_cost > cash:
+        conn.close()
+        return {"error": f"Insufficient cash. Need ${total_cost:.2f}, have ${cash:.2f}"}
+
+    new_cash = cash - total_cost
+    conn.execute("UPDATE portfolio_meta SET cash = ?, updated_at = datetime('now') WHERE id = 1", (new_cash,))
+
+    existing = conn.execute("SELECT * FROM positions WHERE ticker = ? AND side = 'LONG'", (ticker,)).fetchone()
+    if existing:
+        old_shares = existing["shares"]
+        old_avg = existing["avg_cost"]
+        new_shares = old_shares + shares
+        new_avg = ((old_shares * old_avg) + (shares * exec_price)) / new_shares
+        conn.execute(
+            "UPDATE positions SET shares = ?, avg_cost = ?, updated_at = datetime('now') WHERE ticker = ? AND side = 'LONG'",
+            (new_shares, new_avg, ticker)
+        )
+    else:
+        conn.execute(
+            "INSERT INTO positions (ticker, asset_type, shares, avg_cost, side) VALUES (?, ?, ?, ?, 'LONG')",
+            (ticker, asset_type, shares, exec_price)
+        )
+
+    conn.execute(
+        """INSERT INTO transactions (ticker, asset_type, action, side, shares, price, slippage, commission, total)
+           VALUES (?, ?, 'BUY', 'LONG', ?, ?, ?, ?, ?)""",
+        (ticker, asset_type, shares, exec_price, slip * shares, commission, total_cost)
+    )
+    conn.commit()
+    conn.close()
+
+    return {
+        "success": True, "action": "BUY", "ticker": ticker,
+        "shares": shares, "price": round(exec_price, 4),
+        "slippage": round(slip, 4), "commission": round(commission, 2),
+        "total": round(total_cost, 2), "remaining_cash": round(new_cash, 2)
+    }
+
+
+def sell(ticker, shares, price):
+    """Sell long shares with slippage and commission."""
+    if shares <= 0 or price <= 0:
+        return {"error": "Invalid shares or price"}
+
+    conn = get_db()
+    meta = _get_meta(conn)
+    slippage_bps = meta["slippage_bps"]
+    comm_per_share = meta["commission_per_share"]
+
+    existing = conn.execute("SELECT * FROM positions WHERE ticker = ? AND side = 'LONG'", (ticker,)).fetchone()
+    if not existing or existing["shares"] < shares:
+        conn.close()
+        available = existing["shares"] if existing else 0
+        return {"error": f"Insufficient shares. Have {available}, trying to sell {shares}"}
+
+    slip = _calc_slippage(price, shares, slippage_bps, "SELL")
+    exec_price = price + slip  # slip is negative for sells
+    commission = _calc_commission(shares, comm_per_share)
+    total_proceeds = shares * exec_price - commission
+
+    new_shares = existing["shares"] - shares
+    cash = meta["cash"]
+    new_cash = cash + total_proceeds
+
+    conn.execute("UPDATE portfolio_meta SET cash = ?, updated_at = datetime('now') WHERE id = 1", (new_cash,))
+
+    if new_shares <= 0:
+        conn.execute("DELETE FROM positions WHERE ticker = ? AND side = 'LONG'", (ticker,))
+    else:
+        conn.execute(
+            "UPDATE positions SET shares = ?, updated_at = datetime('now') WHERE ticker = ? AND side = 'LONG'",
+            (new_shares, ticker)
+        )
+
+    pnl = (exec_price - existing["avg_cost"]) * shares - commission
+    conn.execute(
+        """INSERT INTO transactions (ticker, asset_type, action, side, shares, price, slippage, commission, total, pnl)
+           VALUES (?, ?, 'SELL', 'LONG', ?, ?, ?, ?, ?, ?)""",
+        (ticker, existing["asset_type"], shares, exec_price, slip * shares, commission, total_proceeds, pnl)
+    )
+    conn.commit()
+    conn.close()
+
+    return {
+        "success": True, "action": "SELL", "ticker": ticker,
+        "shares": shares, "price": round(exec_price, 4),
+        "slippage": round(slip, 4), "commission": round(commission, 2),
+        "total": round(total_proceeds, 2), "pnl": round(pnl, 2),
+        "remaining_cash": round(new_cash, 2)
+    }
+
+
+def short_sell(ticker, shares, price, asset_type="stock"):
+    """Open a short position. Margin is deducted from cash."""
+    if shares <= 0 or price <= 0:
+        return {"error": "Invalid shares or price"}
+
+    conn = get_db()
+    meta = _get_meta(conn)
+    cash = meta["cash"]
+    slippage_bps = meta["slippage_bps"]
+    comm_per_share = meta["commission_per_share"]
+
+    slip = _calc_slippage(price, shares, slippage_bps, "SELL")
+    exec_price = price + slip  # worse price when selling (slippage)
+    commission = _calc_commission(shares, comm_per_share)
+
+    # Margin requirement: 100% of position value + commission
+    margin_req = shares * exec_price + commission
+    if margin_req > cash:
+        conn.close()
+        return {"error": f"Insufficient funds. Need ${margin_req:.2f}, have ${cash:.2f}"}
+
+    # Deduct margin from cash (no proceeds added — paper trading model)
+    new_cash = cash - margin_req
+    new_margin = meta["margin_used"] + (shares * exec_price)
+
+    conn.execute("UPDATE portfolio_meta SET cash = ?, margin_used = ?, updated_at = datetime('now') WHERE id = 1",
+                 (new_cash, new_margin))
+
+    existing = conn.execute("SELECT * FROM positions WHERE ticker = ? AND side = 'SHORT'", (ticker,)).fetchone()
+    if existing:
+        old_shares = existing["shares"]
+        old_avg = existing["avg_cost"]
+        new_shares = old_shares + shares
+        new_avg = ((old_shares * old_avg) + (shares * exec_price)) / new_shares
+        conn.execute(
+            "UPDATE positions SET shares = ?, avg_cost = ?, updated_at = datetime('now') WHERE ticker = ? AND side = 'SHORT'",
+            (new_shares, new_avg, ticker)
+        )
+    else:
+        conn.execute(
+            "INSERT INTO positions (ticker, asset_type, shares, avg_cost, side) VALUES (?, ?, ?, ?, 'SHORT')",
+            (ticker, asset_type, shares, exec_price)
+        )
+
+    conn.execute(
+        """INSERT INTO transactions (ticker, asset_type, action, side, shares, price, slippage, commission, total)
+           VALUES (?, ?, 'SHORT', 'SHORT', ?, ?, ?, ?, ?)""",
+        (ticker, asset_type, shares, exec_price, abs(slip) * shares, commission, margin_req)
+    )
+    conn.commit()
+    conn.close()
+
+    return {
+        "success": True, "action": "SHORT", "ticker": ticker,
+        "shares": shares, "price": round(exec_price, 4),
+        "margin_required": round(margin_req, 2),
+        "commission": round(commission, 2)
+    }
+
+
+def cover_short(ticker, shares, price):
+    """Cover (buy back) a short position. Releases margin + P&L to cash."""
+    if shares <= 0 or price <= 0:
+        return {"error": "Invalid shares or price"}
+
+    conn = get_db()
+    meta = _get_meta(conn)
+    slippage_bps = meta["slippage_bps"]
+    comm_per_share = meta["commission_per_share"]
+
+    existing = conn.execute("SELECT * FROM positions WHERE ticker = ? AND side = 'SHORT'", (ticker,)).fetchone()
+    if not existing or existing["shares"] < shares:
+        conn.close()
+        available = existing["shares"] if existing else 0
+        return {"error": f"No short position. Have {available} short shares."}
+
+    slip = _calc_slippage(price, shares, slippage_bps, "BUY")
+    exec_price = price + slip  # worse price when buying back (slippage)
+    commission = _calc_commission(shares, comm_per_share)
+
+    # P&L: profit when we shorted high and cover low
+    entry_value = shares * existing["avg_cost"]
+    cover_cost = shares * exec_price
+    pnl = entry_value - cover_cost - commission  # short profit when price drops
+
+    # Release margin and return to cash with P&L
+    cash = meta["cash"]
+    margin_release = entry_value  # we held 100% of entry value as margin
+    new_cash = cash + margin_release + pnl  # margin back + profit/loss
+    new_margin = max(0, meta["margin_used"] - margin_release)
+
+    conn.execute("UPDATE portfolio_meta SET cash = ?, margin_used = ?, updated_at = datetime('now') WHERE id = 1",
+                 (new_cash, new_margin))
+
+    new_shares = existing["shares"] - shares
+    if new_shares <= 0:
+        conn.execute("DELETE FROM positions WHERE ticker = ? AND side = 'SHORT'", (ticker,))
+    else:
+        conn.execute(
+            "UPDATE positions SET shares = ?, updated_at = datetime('now') WHERE ticker = ? AND side = 'SHORT'",
+            (new_shares, ticker)
+        )
+
+    conn.execute(
+        """INSERT INTO transactions (ticker, asset_type, action, side, shares, price, slippage, commission, total, pnl)
+           VALUES (?, ?, 'COVER', 'SHORT', ?, ?, ?, ?, ?, ?)""",
+        (ticker, existing["asset_type"], shares, exec_price, abs(slip) * shares, commission, cover_cost + commission, pnl)
+    )
+    conn.commit()
+    conn.close()
+
+    return {
+        "success": True, "action": "COVER", "ticker": ticker,
+        "shares": shares, "price": round(exec_price, 4),
+        "pnl": round(pnl, 2), "commission": round(commission, 2),
+        "remaining_cash": round(new_cash, 2)
+    }
+
+
+# ── Pending Orders (Limit / Stop) ────────────────────────
+
+def place_limit_order(ticker, side, shares, limit_price, asset_type="stock", expires_hours=24):
+    """Place a limit order that fills when market price hits the target."""
+    if shares <= 0 or limit_price <= 0:
+        return {"error": "Invalid order parameters"}
+
+    expires = datetime.now()
+    from datetime import timedelta
+    expires = (expires + timedelta(hours=expires_hours)).isoformat()
+
+    conn = get_db()
+    conn.execute(
+        """INSERT INTO pending_orders (ticker, asset_type, order_type, side, shares, target_price, expires_at)
+           VALUES (?, ?, 'LIMIT', ?, ?, ?, ?)""",
+        (ticker, asset_type, side, shares, limit_price, expires)
+    )
+    conn.commit()
+    order_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+    conn.close()
+
+    return {"success": True, "order_id": order_id, "order_type": "LIMIT",
+            "side": side, "ticker": ticker, "shares": shares,
+            "target_price": limit_price, "expires_at": expires}
+
+
+def place_stop_order(ticker, side, shares, stop_price, asset_type="stock", expires_hours=24):
+    """Place a stop order (stop-loss or take-profit)."""
+    if shares <= 0 or stop_price <= 0:
+        return {"error": "Invalid order parameters"}
+
+    expires = datetime.now()
+    from datetime import timedelta
+    expires = (expires + timedelta(hours=expires_hours)).isoformat()
+
+    conn = get_db()
+    conn.execute(
+        """INSERT INTO pending_orders (ticker, asset_type, order_type, side, shares, target_price, expires_at)
+           VALUES (?, ?, 'STOP', ?, ?, ?, ?)""",
+        (ticker, asset_type, side, shares, stop_price, expires)
+    )
+    conn.commit()
+    order_id = conn.execute("SELECT last_insert_rowid()").fetchone()[0]
+    conn.close()
+
+    return {"success": True, "order_id": order_id, "order_type": "STOP",
+            "side": side, "ticker": ticker, "shares": shares,
+            "target_price": stop_price, "expires_at": expires}
+
+
+def get_pending_orders():
+    """Get all pending orders."""
+    conn = get_db()
+    # Expire old orders
+    conn.execute("UPDATE pending_orders SET status = 'EXPIRED' WHERE status = 'PENDING' AND expires_at < datetime('now')")
+    conn.commit()
+    rows = conn.execute("SELECT * FROM pending_orders WHERE status = 'PENDING' ORDER BY created_at DESC").fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def cancel_order(order_id):
+    """Cancel a pending order."""
+    conn = get_db()
+    conn.execute("UPDATE pending_orders SET status = 'CANCELLED' WHERE id = ? AND status = 'PENDING'", (order_id,))
+    conn.commit()
+    conn.close()
+    return {"success": True, "order_id": order_id, "status": "CANCELLED"}
+
+
+def check_and_fill_orders(current_prices):
+    """Check pending orders against current prices and fill if conditions met.
+    Called during live polling.
+    current_prices: dict {ticker: price}
+    """
+    conn = get_db()
+    pending = conn.execute("SELECT * FROM pending_orders WHERE status = 'PENDING'").fetchall()
+    filled = []
+
+    for order in pending:
+        order = dict(order)
+        ticker = order["ticker"]
+        if ticker not in current_prices:
+            continue
+
+        market_price = current_prices[ticker]
+        should_fill = False
+
+        if order["order_type"] == "LIMIT":
+            if order["side"] == "BUY" and market_price <= order["target_price"]:
+                should_fill = True
+            elif order["side"] == "SELL" and market_price >= order["target_price"]:
+                should_fill = True
+        elif order["order_type"] == "STOP":
+            if order["side"] == "SELL" and market_price <= order["target_price"]:
+                should_fill = True  # stop-loss triggered
+            elif order["side"] == "BUY" and market_price >= order["target_price"]:
+                should_fill = True  # stop-buy triggered
+
+        if should_fill:
+            conn.execute("UPDATE pending_orders SET status = 'FILLED', filled_at = datetime('now') WHERE id = ?",
+                         (order["id"],))
+
+            if order["side"] == "BUY":
+                result = buy(ticker, order["shares"], market_price, order["asset_type"])
+            else:
+                result = sell(ticker, order["shares"], market_price)
+
+            filled.append({"order_id": order["id"], "ticker": ticker, "result": result})
+
+    conn.commit()
+    conn.close()
+    return filled
+
+
+# ── Equity Curve ──────────────────────────────────────
+
+def record_equity_point(total_value, cash, positions_value):
+    """Record a point on the equity curve."""
+    conn = get_db()
+    # Get last point for daily return calc
+    last = conn.execute("SELECT total_value FROM equity_curve ORDER BY id DESC LIMIT 1").fetchone()
+    daily_return = 0
+    if last and last["total_value"] > 0:
+        daily_return = (total_value - last["total_value"]) / last["total_value"]
+
+    conn.execute(
+        "INSERT INTO equity_curve (timestamp, total_value, cash, positions_value, daily_return) VALUES (datetime('now'), ?, ?, ?, ?)",
+        (total_value, cash, positions_value, daily_return)
+    )
+    conn.commit()
+    conn.close()
+
+
+def get_equity_curve(limit=500):
+    """Get equity curve data for charting."""
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT timestamp, total_value, cash, positions_value, daily_return FROM equity_curve ORDER BY id DESC LIMIT ?",
+        (limit,)
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in reversed(rows)]
+
+
+# ── Portfolio Summary ─────────────────────────────────
+
+def get_portfolio_summary(current_prices=None):
+    if current_prices is None:
+        current_prices = {}
+
+    conn = get_db()
+    meta = _get_meta(conn)
+    cash = meta["cash"]
+    margin_used = meta["margin_used"]
+    positions = conn.execute("SELECT * FROM positions WHERE shares > 0").fetchall()
+    conn.close()
+
+    pos_list = []
+    total_long_value = 0
+    total_short_value = 0
+    total_cost_basis = 0
+
+    for p in positions:
+        ticker = p["ticker"]
+        shares = p["shares"]
+        avg_cost = p["avg_cost"]
+        side = p["side"]
+        current_price = current_prices.get(ticker, avg_cost)
+
+        if side == "LONG":
+            market_value = shares * current_price
+            cost_basis = shares * avg_cost
+            pnl = market_value - cost_basis
+            total_long_value += market_value
+        else:  # SHORT
+            market_value = shares * avg_cost  # short value is entry value
+            cost_basis = shares * avg_cost
+            pnl = (avg_cost - current_price) * shares  # profit when price drops
+            total_short_value += shares * current_price
+
+        pnl_pct = (pnl / cost_basis * 100) if cost_basis > 0 else 0
+        total_cost_basis += cost_basis
+
+        pos_list.append({
+            "ticker": ticker, "asset_type": p["asset_type"],
+            "shares": shares, "avg_cost": round(avg_cost, 2),
+            "current_price": round(current_price, 2),
+            "market_value": round(market_value, 2),
+            "side": side,
+            "cost_basis": round(cost_basis, 2),
+            "pnl": round(pnl, 2), "pnl_pct": round(pnl_pct, 2),
+            "allocation_pct": 0
+        })
+
+    positions_value = total_long_value
+    # total_value = available cash + long positions + margin held + unrealized short P&L
+    # margin_used tracks entry value of shorts (deducted from cash at open)
+    # short_unrealized_pnl = sum of (entry_price - current_price) * shares for shorts
+    short_unrealized_pnl = 0
+    for p in pos_list:
+        if p["side"] == "SHORT":
+            short_unrealized_pnl += p["pnl"]
+    total_value = cash + positions_value + margin_used + short_unrealized_pnl
+    total_pnl = total_value - INITIAL_CASH
+    total_pnl_pct = (total_pnl / INITIAL_CASH * 100)
+
+    for p in pos_list:
+        p["allocation_pct"] = round((abs(p["market_value"]) / total_value * 100) if total_value > 0 else 0, 2)
+
+    return {
+        "cash": round(cash, 2),
+        "positions_value": round(positions_value, 2),
+        "total_value": round(total_value, 2),
+        "total_pnl": round(total_pnl, 2),
+        "total_pnl_pct": round(total_pnl_pct, 2),
+        "initial_capital": INITIAL_CASH,
+        "margin_used": round(margin_used, 2),
+        "buying_power": round(cash, 2),
+        "positions": pos_list,
+        "cash_allocation_pct": round((cash / total_value * 100) if total_value > 0 else 100, 2),
+        "slippage_bps": round(meta["slippage_bps"], 1),
+        "commission_per_share": round(meta["commission_per_share"], 4),
+    }
+
+
+def get_transactions(limit=50):
+    conn = get_db()
+    rows = conn.execute(
+        "SELECT * FROM transactions ORDER BY timestamp DESC LIMIT ?", (limit,)
+    ).fetchall()
+    conn.close()
+    return [dict(r) for r in rows]
+
+
+def get_analytics(current_prices=None):
+    """Enhanced analytics with Sortino, Calmar, profit factor."""
+    conn = get_db()
+    txns = conn.execute("SELECT * FROM transactions ORDER BY timestamp ASC").fetchall()
+    equity = conn.execute("SELECT * FROM equity_curve ORDER BY id ASC").fetchall()
+    conn.close()
+
+    if not txns:
+        return _empty_analytics()
+
+    # Daily returns from equity curve
+    daily_returns = [dict(e)["daily_return"] for e in equity if dict(e)["daily_return"] != 0]
+
+    if len(daily_returns) >= 2:
+        avg_ret = sum(daily_returns) / len(daily_returns)
+        std_ret = math.sqrt(sum((r - avg_ret) ** 2 for r in daily_returns) / len(daily_returns))
+        neg_returns = [r for r in daily_returns if r < 0]
+        downside_dev = math.sqrt(sum(r ** 2 for r in neg_returns) / len(neg_returns)) if neg_returns else 0
+
+        sharpe = (avg_ret / std_ret * math.sqrt(252)) if std_ret > 0 else 0
+        sortino = (avg_ret / downside_dev * math.sqrt(252)) if downside_dev > 0 else 0
+
+        # Max drawdown
+        values = [dict(e)["total_value"] for e in equity]
+        peak = values[0] if values else INITIAL_CASH
+        max_dd = 0
+        for v in values:
+            if v > peak: peak = v
+            dd = (peak - v) / peak
+            if dd > max_dd: max_dd = dd
+
+        # Calmar ratio (annualized return / max drawdown)
+        total_return = (values[-1] / values[0] - 1) if values and values[0] > 0 else 0
+        calmar = (total_return / max_dd) if max_dd > 0 else 0
+    else:
+        sharpe = sortino = calmar = 0
+        max_dd = 0
+
+    # Trade analysis
+    pnls = []
+    for t in txns:
+        t = dict(t)
+        if t.get("pnl") is not None:
+            pnls.append(t["pnl"])
+
+    wins = [p for p in pnls if p > 0]
+    losses = [p for p in pnls if p <= 0]
+    total_trades = len(pnls)
+    win_rate = (len(wins) / total_trades * 100) if total_trades > 0 else 0
+
+    gross_profit = sum(wins) if wins else 0
+    gross_loss = abs(sum(losses)) if losses else 0
+    profit_factor = (gross_profit / gross_loss) if gross_loss > 0 else float('inf') if gross_profit > 0 else 0
+
+    # Total commissions and slippage
+    total_commission = sum(dict(t).get("commission", 0) for t in txns)
+    total_slippage = sum(abs(dict(t).get("slippage", 0)) for t in txns)
+
+    summary = get_portfolio_summary(current_prices)
+
+    return {
+        "sharpe_ratio": round(sharpe, 2),
+        "sortino_ratio": round(sortino, 2),
+        "calmar_ratio": round(calmar, 2),
+        "max_drawdown_pct": round(max_dd * 100, 2),
+        "profit_factor": round(profit_factor, 2) if profit_factor != float('inf') else "∞",
+        "win_rate": round(win_rate, 1),
+        "total_trades": total_trades,
+        "winning_trades": len(wins),
+        "losing_trades": len(losses),
+        "avg_win": round(sum(wins) / len(wins), 2) if wins else 0,
+        "avg_loss": round(sum(losses) / len(losses), 2) if losses else 0,
+        "best_trade": round(max(pnls), 2) if pnls else 0,
+        "worst_trade": round(min(pnls), 2) if pnls else 0,
+        "total_return_pct": round(summary["total_pnl_pct"], 2),
+        "total_commission": round(total_commission, 2),
+        "total_slippage": round(total_slippage, 2),
+        "gross_profit": round(gross_profit, 2),
+        "gross_loss": round(gross_loss, 2),
+    }
+
+
+def _empty_analytics():
+    return {
+        "sharpe_ratio": 0, "sortino_ratio": 0, "calmar_ratio": 0,
+        "max_drawdown_pct": 0, "profit_factor": 0,
+        "win_rate": 0, "total_trades": 0,
+        "winning_trades": 0, "losing_trades": 0,
+        "avg_win": 0, "avg_loss": 0,
+        "best_trade": 0, "worst_trade": 0,
+        "total_return_pct": 0, "total_commission": 0, "total_slippage": 0,
+        "gross_profit": 0, "gross_loss": 0,
+    }
+
+
+def save_daily_snapshot(total_value, cash, positions_value):
+    conn = get_db()
+    today = datetime.now().strftime("%Y-%m-%d")
+    conn.execute(
+        "INSERT OR REPLACE INTO portfolio_snapshots (date, total_value, cash, positions_value) VALUES (?, ?, ?, ?)",
+        (today, total_value, cash, positions_value)
+    )
+    conn.commit()
+    conn.close()
+
+
+def reset_portfolio():
+    """Reset portfolio to initial state — clears everything."""
+    conn = get_db()
+    conn.execute("DELETE FROM portfolio_meta")
+    conn.execute("INSERT INTO portfolio_meta (id, cash) VALUES (1, ?)", (INITIAL_CASH,))
+    conn.execute("DELETE FROM positions")
+    conn.execute("DELETE FROM transactions")
+    conn.execute("DELETE FROM pending_orders")
+    conn.execute("DELETE FROM equity_curve")
+    conn.execute("DELETE FROM portfolio_snapshots")
+    conn.commit()
+    conn.close()
+    return {"success": True, "message": "Portfolio reset to $100,000"}
+
+
+def update_settings(slippage_bps=None, commission_per_share=None):
+    """Update portfolio simulation settings."""
+    conn = get_db()
+    if slippage_bps is not None:
+        conn.execute("UPDATE portfolio_meta SET slippage_bps = ? WHERE id = 1", (slippage_bps,))
+    if commission_per_share is not None:
+        conn.execute("UPDATE portfolio_meta SET commission_per_share = ? WHERE id = 1", (commission_per_share,))
+    conn.commit()
+    conn.close()
+    return {"success": True}
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..685136e
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,7 @@
+flask>=3.0
+yfinance>=1.0
+financetoolkit>=2.0
+openpyxl>=3.1
+requests>=2.31
+requests-cache>=1.2
+python-dotenv>=1.0
diff --git a/static/script.js b/static/script.js
new file mode 100644
index 0000000..3fcc2de
--- /dev/null
+++ b/static/script.js
@@ -0,0 +1,1649 @@
+/* FinanceIQ v5 — Frontend Logic */
+
+// ══════════════ THEME TOGGLE ══════════════
+function getTheme() { return localStorage.getItem('fiq-theme') || 'dark'; }
+function setTheme(t) {
+    document.documentElement.setAttribute('data-theme', t);
+    localStorage.setItem('fiq-theme', t);
+    const icon = document.getElementById('themeIcon');
+    const label = document.getElementById('themeLabel');
+    if (icon) icon.setAttribute('data-lucide', t === 'dark' ? 'moon' : 'sun');
+    if (label) label.textContent = t === 'dark' ? 'Dark Mode' : 'Light Mode';
+    if (typeof lucide !== 'undefined') lucide.createIcons();
+    // Update charts if they exist
+    if (chartInstance) updateChartTheme();
+    if (mcChartInstance) updateMCChartTheme();
+}
+function updateChartTheme() {
+    const t = getTheme();
+    const bg = t === 'dark' ? '#141a2a' : '#ffffff';
+    const txt = t === 'dark' ? '#8b95a8' : '#5a6577';
+    const grid = t === 'dark' ? 'rgba(255,255,255,0.03)' : 'rgba(0,0,0,0.04)';
+    const border = t === 'dark' ? 'rgba(255,255,255,0.1)' : 'rgba(0,0,0,0.1)';
+    chartInstance.applyOptions({ layout: { background: { color: bg }, textColor: txt }, grid: { vertLines: { color: grid }, horzLines: { color: grid } }, timeScale: { borderColor: border }, rightPriceScale: { borderColor: border } });
+}
+function updateMCChartTheme() {
+    const t = getTheme();
+    const bg = t === 'dark' ? '#141a2a' : '#ffffff';
+    const txt = t === 'dark' ? '#8b95a8' : '#5a6577';
+    const grid = t === 'dark' ? 'rgba(255,255,255,0.03)' : 'rgba(0,0,0,0.04)';
+    const border = t === 'dark' ? 'rgba(255,255,255,0.1)' : 'rgba(0,0,0,0.1)';
+    mcChartInstance.applyOptions({ layout: { background: { color: bg }, textColor: txt }, grid: { vertLines: { color: grid }, horzLines: { color: grid } }, timeScale: { borderColor: border }, rightPriceScale: { borderColor: border } });
+}
+function getChartColors() {
+    const t = getTheme();
+    return {
+        bg: t === 'dark' ? '#141a2a' : '#ffffff',
+        text: t === 'dark' ? '#8b95a8' : '#5a6577',
+        grid: t === 'dark' ? 'rgba(255,255,255,0.03)' : 'rgba(0,0,0,0.04)',
+        border: t === 'dark' ? 'rgba(255,255,255,0.1)' : 'rgba(0,0,0,0.1)',
+    };
+}
+// Apply saved theme on load
+document.addEventListener('DOMContentLoaded', () => {
+    setTheme(getTheme());
+    const themeBtn = document.getElementById('themeToggle');
+    if (themeBtn) themeBtn.addEventListener('click', () => setTheme(getTheme() === 'dark' ? 'light' : 'dark'));
+    // Sidebar toggle for mobile
+    const sidebarToggle = document.getElementById('sidebarToggle');
+    const sidebar = document.getElementById('sidebar');
+    if (sidebarToggle && sidebar) {
+        sidebarToggle.addEventListener('click', () => sidebar.classList.toggle('open'));
+    }
+    // Asset type selector
+    document.querySelectorAll('.asset-btn').forEach(btn => {
+        btn.addEventListener('click', () => {
+            document.querySelectorAll('.asset-btn').forEach(b => b.classList.remove('active'));
+            btn.classList.add('active');
+            currentAssetType = btn.dataset.asset;
+            const input = document.getElementById('tickerInput');
+            const placeholders = { stocks: 'Search ticker (e.g. AAPL, TSLA, NIFTY)', futures: 'Search futures (e.g. ES=F, NQ=F, GC=F)', options: 'Search underlying (e.g. AAPL, SPY)', currencies: 'Search pair (e.g. USDINR=X, EURUSD=X)' };
+            if (input) input.placeholder = placeholders[currentAssetType] || placeholders.stocks;
+            // Filter sidebar nav items by asset type
+            filterSidebarByAsset(currentAssetType);
+        });
+    });
+});
+
+let chartInstance = null;
+let candleSeries = null;
+let volumeSeries = null;
+let overlays = {};
+let analysisData = null;
+let newsData = null;
+let currentTicker = "";
+let currentAssetType = "stocks";
+
+// Helper: detect asset type from ticker
+function getAssetType(ticker) {
+    if (!ticker) return currentAssetType;
+    if (ticker.endsWith('=F')) return 'futures';
+    if (ticker.endsWith('=X')) return 'currencies';
+    if (ticker.startsWith('^')) return 'stocks'; // indices treated as stocks
+    return currentAssetType; // use the selector's value
+}
+
+// Filter sidebar nav items by asset type
+function filterSidebarByAsset(assetType) {
+    document.querySelectorAll('.nav-item[data-asset]').forEach(btn => {
+        const allowed = (btn.dataset.asset || '').split(',');
+        if (allowed.includes(assetType)) {
+            btn.style.display = '';
+        } else {
+            btn.style.display = 'none';
+            // If this tab was active, switch to overview
+            if (btn.classList.contains('active')) {
+                btn.classList.remove('active');
+                document.querySelectorAll('.tab-page').forEach(p => p.classList.remove('active'));
+                const overviewBtn = document.querySelector('.nav-item[data-tab="overview"]');
+                if (overviewBtn) overviewBtn.classList.add('active');
+                const overviewPage = document.getElementById('page-overview');
+                if (overviewPage) overviewPage.classList.add('active');
+            }
+        }
+    });
+}
+
+// ══════════════ CURRENCY STATE ══════════════
+let currencyRates = { USD: 1.0, GBP: 0.79, INR: 83.5 };
+let currentCurrency = "GBP"; // default
+const currencySymbols = { USD: "$", GBP: "£", INR: "₹" };
+
+// Fetch live rates on load
+(async function fetchCurrencyRates() {
+    try {
+        const res = await fetch("/api/currency", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) });
+        const data = await res.json();
+        currencyRates = data;
+    } catch (e) { console.warn("Using fallback currency rates"); }
+})();
+
+function convertCurrency(usdValue) {
+    if (usdValue === null || usdValue === undefined || usdValue === "N/A") return "N/A";
+    const n = parseFloat(usdValue);
+    if (isNaN(n)) return String(usdValue);
+    return n * currencyRates[currentCurrency];
+}
+function fmtCurrency(usdValue) {
+    const c = convertCurrency(usdValue);
+    if (c === "N/A") return "N/A";
+    const sym = currencySymbols[currentCurrency];
+    return sym + Number(c).toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+
+// ══════════════ WELCOME PAGE ══════════════
+document.getElementById("letsBeginBtn").addEventListener("click", () => {
+    document.getElementById("welcomePage").style.display = "none";
+    document.getElementById("mainApp").style.display = "flex";
+});
+
+// ══════════════ SIDEBAR NAVIGATION ══════════════
+document.querySelectorAll(".nav-item[data-tab]").forEach(btn => {
+    btn.addEventListener("click", () => {
+        document.querySelectorAll(".nav-item[data-tab]").forEach(b => b.classList.remove("active"));
+        document.querySelectorAll(".tab-page").forEach(p => p.classList.remove("active"));
+        btn.classList.add("active");
+        document.getElementById("page-" + btn.dataset.tab).classList.add("active");
+        // Close mobile sidebar
+        const sidebar = document.getElementById('sidebar');
+        if (sidebar && window.innerWidth <= 1024) sidebar.classList.remove('open');
+    });
+});
+
+// ══════════════ SEARCH / SUGGEST ══════════════
+const tickerInput = document.getElementById("tickerInput");
+const dropdown = document.getElementById("dropdown");
+const timeframeSelect = document.getElementById("timeframeSelect");
+const periodSelect = document.getElementById("periodSelect");
+const currencySelect = document.getElementById("currencySelect");
+const customDates = document.getElementById("customDates");
+let debounceTimer;
+
+tickerInput.addEventListener("input", () => {
+    clearTimeout(debounceTimer);
+    debounceTimer = setTimeout(async () => {
+        const q = tickerInput.value.trim();
+        if (q.length < 1) { dropdown.style.display = "none"; return; }
+        try {
+            const res = await fetch(`/api/suggest?q=${encodeURIComponent(q)}&asset_type=${encodeURIComponent(currentAssetType)}`);
+            const data = await res.json();
+            if (!data.length) { dropdown.style.display = "none"; return; }
+            dropdown.innerHTML = data.map(d =>
+                `<div class="dropdown-item" data-ticker="${d.ticker}">
+                    <span class="dropdown-ticker">${d.ticker}</span>
+                    <span class="dropdown-name">${d.name}</span>
+                </div>`
+            ).join("");
+            dropdown.style.display = "block";
+            dropdown.querySelectorAll(".dropdown-item").forEach(item => {
+                item.addEventListener("click", () => {
+                    tickerInput.value = item.dataset.ticker;
+                    dropdown.style.display = "none";
+                });
+            });
+        } catch (e) { dropdown.style.display = "none"; }
+    }, 200);
+});
+
+tickerInput.addEventListener("keydown", e => { if (e.key === "Enter") { dropdown.style.display = "none"; runAnalysis(); } });
+document.addEventListener("click", e => { if (!e.target.closest(".ticker-wrapper")) dropdown.style.display = "none"; });
+timeframeSelect.addEventListener("change", () => { customDates.style.display = timeframeSelect.value === "custom" ? "flex" : "none"; });
+currencySelect.addEventListener("change", () => {
+    currentCurrency = currencySelect.value;
+    if (analysisData) refreshCurrencyDisplay();
+});
+document.getElementById("analyzeBtn").addEventListener("click", runAnalysis);
+
+// ══════════════ REFRESH CURRENCY DISPLAY ══════════════
+function refreshCurrencyDisplay() {
+    if (!analysisData) return;
+    renderKeyMetrics(analysisData);
+    renderTechnicalIndicators(analysisData);
+    renderFinancials(analysisData);
+    // Re-render items that show currency values
+    if (analysisData._dcf) renderDCFData(analysisData._dcf);
+    if (analysisData._dividends) renderDividendData(analysisData._dividends);
+    if (analysisData._mc) renderMCStats(analysisData._mc);
+}
+
+// ══════════════ MAIN ANALYSIS ══════════════
+async function runAnalysis() {
+    const ticker = tickerInput.value.trim().toUpperCase();
+    if (!ticker) return;
+    currentTicker = ticker;
+    const detectedType = getAssetType(ticker);
+    filterSidebarByAsset(detectedType);
+
+    showLoader("Fetching market data...");
+    const body = { ticker, timeframe: timeframeSelect.value, period: periodSelect.value };
+    if (timeframeSelect.value === "custom") {
+        body.start = document.getElementById("startDate").value;
+        body.end = document.getElementById("endDate").value;
+    }
+
+    try {
+        updateLoader("Analyzing " + ticker + "...");
+        const res = await fetch("/api/analyze", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(body) });
+        if (!res.ok) { const err = await res.json().catch(() => ({})); throw new Error(err.error || `HTTP ${res.status}`); }
+        analysisData = await res.json();
+
+        const exportBtn = document.getElementById("exportBtnSidebar");
+        if (exportBtn) exportBtn.style.display = "flex";
+        document.querySelectorAll(".nav-item[data-tab]").forEach(b => b.classList.remove("active"));
+        document.querySelectorAll(".tab-page").forEach(p => p.classList.remove("active"));
+        document.querySelector('.nav-item[data-tab="overview"]').classList.add("active");
+        document.getElementById("page-overview").classList.add("active");
+
+        // Always render chart & key metrics
+        renderChart(analysisData);
+        renderKeyMetrics(analysisData);
+        renderQuickSignal(analysisData);
+        renderTechnicalIndicators(analysisData);
+
+        // Conditional fetches based on asset type
+        if (detectedType === 'stocks') {
+            renderFinancials(analysisData);
+            fetchPatterns(ticker, analysisData.price_history);
+            fetchAnalyst(ticker);
+            fetchInsider(ticker);
+            fetchEarnings(ticker);
+            fetchDCF(ticker);
+            fetchZScore(ticker);
+            fetchDividends(ticker);
+            fetchHeatmap();
+            fetchCompetitors(ticker);
+        }
+
+        if (detectedType === 'stocks' || detectedType === 'futures') {
+            fetchMonteCarlo(ticker, analysisData.price_history);
+            fetchCorrelation(ticker);
+            fetchMacro();
+            fetchPatterns(ticker, analysisData.price_history);
+        }
+
+        if (detectedType === 'currencies') {
+            fetchMonteCarlo(ticker, analysisData.price_history);
+            fetchCorrelation(ticker);
+        }
+
+        if (detectedType === 'options') {
+            // Load the options chain for this ticker
+            loadOptionsChainForTicker(ticker);
+        }
+
+        // Always fetch these
+        fetchSentiment();
+        fetchNews(ticker);
+        fetchAI(ticker);
+
+        hideLoader();
+        startLivePolling();
+
+    } catch (err) {
+        hideLoader();
+        alert("Error: " + err.message);
+    }
+}
+
+// ══════════════ LOADER ══════════════
+function showLoader(msg) { document.getElementById("loader").style.display = "flex"; document.getElementById("loaderText").textContent = msg || "Analyzing..."; }
+function updateLoader(msg) { document.getElementById("loaderText").textContent = msg; }
+function hideLoader() { document.getElementById("loader").style.display = "none"; }
+
+// ══════════════ CHART ══════════════
+let chartResizeObserver = null;
+
+function renderChart(data) {
+    const container = document.getElementById("chartContainer");
+    container.innerHTML = "";
+    document.getElementById("chartControls").style.display = "flex";
+
+    // Cleanup previous chart & observer
+    if (chartResizeObserver) { chartResizeObserver.disconnect(); chartResizeObserver = null; }
+    if (chartInstance) { chartInstance.remove(); chartInstance = null; }
+
+    const cc = getChartColors();
+    const rect = container.getBoundingClientRect();
+    chartInstance = LightweightCharts.createChart(container, {
+        width: rect.width || 800,
+        height: rect.height || 420,
+        layout: { background: { color: cc.bg }, textColor: cc.text },
+        grid: { vertLines: { color: cc.grid }, horzLines: { color: cc.grid } },
+        crosshair: { mode: LightweightCharts.CrosshairMode.Normal },
+        timeScale: { borderColor: cc.border, timeVisible: false },
+        rightPriceScale: { borderColor: cc.border },
+    });
+
+    // Responsive resize
+    chartResizeObserver = new ResizeObserver(entries => {
+        for (const entry of entries) {
+            const { width, height } = entry.contentRect;
+            if (chartInstance && width > 0 && height > 0) {
+                chartInstance.resize(width, height);
+            }
+        }
+    });
+    chartResizeObserver.observe(container);
+
+    candleSeries = chartInstance.addCandlestickSeries({
+        upColor: "#22c55e", downColor: "#ef4444",
+        borderUpColor: "#22c55e", borderDownColor: "#ef4444",
+        wickUpColor: "#22c55e", wickDownColor: "#ef4444"
+    });
+
+    // Validate and sort price data
+    const prices = (data.price_history || [])
+        .filter(p => p.date && p.open != null && p.close != null && !isNaN(p.open) && !isNaN(p.close))
+        .map(p => ({
+            time: String(p.date).slice(0, 10),
+            open: Number(p.open),
+            high: Number(p.high),
+            low: Number(p.low),
+            close: Number(p.close)
+        }))
+        .sort((a, b) => a.time.localeCompare(b.time));
+
+    // Remove duplicates (same date)
+    const seen = new Set();
+    const uniquePrices = prices.filter(p => {
+        if (seen.has(p.time)) return false;
+        seen.add(p.time);
+        return true;
+    });
+    candleSeries.setData(uniquePrices);
+
+    volumeSeries = chartInstance.addHistogramSeries({ priceFormat: { type: "volume" }, priceScaleId: "vol" });
+    chartInstance.priceScale("vol").applyOptions({ scaleMargins: { top: 0.85, bottom: 0 } });
+    const volumeData = (data.price_history || [])
+        .filter(p => p.date && p.volume != null)
+        .map(p => ({
+            time: String(p.date).slice(0, 10),
+            value: Number(p.volume) || 0,
+            color: Number(p.close) >= Number(p.open) ? "rgba(34,197,94,0.3)" : "rgba(239,68,68,0.3)"
+        }))
+        .sort((a, b) => a.time.localeCompare(b.time));
+    const seenVol = new Set();
+    volumeSeries.setData(volumeData.filter(p => { if (seenVol.has(p.time)) return false; seenVol.add(p.time); return true; }));
+
+    chartInstance.timeScale().fitContent();
+    overlays = {};
+    setupOverlayToggles(data);
+}
+
+
+function setupOverlayToggles(data) {
+    const prices = data.price_history || [];
+    const closes = prices.map(p => p.close);
+    const times = prices.map(p => p.time || p.date);
+
+    function ema(arr, period) {
+        const k = 2 / (period + 1);
+        const result = [arr[0]];
+        for (let i = 1; i < arr.length; i++) result.push(arr[i] * k + result[i - 1] * (1 - k));
+        return result;
+    }
+    function sma(arr, period) {
+        const result = [];
+        for (let i = 0; i < arr.length; i++) {
+            if (i < period - 1) { result.push(null); continue; }
+            let sum = 0;
+            for (let j = i - period + 1; j <= i; j++) sum += arr[j];
+            result.push(sum / period);
+        }
+        return result;
+    }
+
+    function addLine(id, values, color) {
+        if (overlays[id]) { chartInstance.removeSeries(overlays[id]); delete overlays[id]; }
+        const s = chartInstance.addLineSeries({ color, lineWidth: 1, priceLineVisible: false, lastValueVisible: false });
+        const d = [];
+        for (let i = 0; i < values.length; i++) { if (values[i] !== null) d.push({ time: times[i], value: values[i] }); }
+        s.setData(d);
+        overlays[id] = s;
+    }
+    function removeLine(id) { if (overlays[id]) { chartInstance.removeSeries(overlays[id]); delete overlays[id]; } }
+
+    const emaConfig = { togEma5: [5, "#f59e0b"], togEma10: [10, "#06b6d4"], togEma20: [20, "#8b5cf6"], togSma200: [200, "#ec4899"] };
+    Object.entries(emaConfig).forEach(([id, [period, color]]) => {
+        const el = document.getElementById(id);
+        if (!el) return;
+        el.checked = false;
+        el.onchange = () => {
+            if (el.checked) {
+                const vals = id.startsWith("togSma") ? sma(closes, period) : ema(closes, period);
+                addLine(id, vals, color);
+            } else removeLine(id);
+        };
+    });
+
+    const bbEl = document.getElementById("togBb");
+    if (bbEl) {
+        bbEl.checked = false;
+        bbEl.onchange = () => {
+            if (bbEl.checked) {
+                const sma20 = sma(closes, 20);
+                const upper = [], lower = [];
+                for (let i = 0; i < closes.length; i++) {
+                    if (sma20[i] === null) { upper.push(null); lower.push(null); continue; }
+                    let sum = 0;
+                    for (let j = i - 19; j <= i; j++) sum += (closes[j] - sma20[i]) ** 2;
+                    const std = Math.sqrt(sum / 20);
+                    upper.push(sma20[i] + 2 * std);
+                    lower.push(sma20[i] - 2 * std);
+                }
+                addLine("bbUpper", upper, "rgba(99,102,241,0.5)");
+                addLine("bbLower", lower, "rgba(99,102,241,0.5)");
+                addLine("bbMid", sma20, "rgba(99,102,241,0.3)");
+            } else { removeLine("bbUpper"); removeLine("bbLower"); removeLine("bbMid"); }
+        };
+    }
+
+    const fibEl = document.getElementById("togFib");
+    if (fibEl) {
+        fibEl.checked = false;
+        fibEl.onchange = () => {
+            if (fibEl.checked) {
+                const hi = Math.max(...closes), lo = Math.min(...closes);
+                [0, 0.236, 0.382, 0.5, 0.618, 0.786, 1].forEach((lvl, idx) => {
+                    const val = hi - (hi - lo) * lvl;
+                    const colors = ["#22c55e", "#84cc16", "#eab308", "#f59e0b", "#f97316", "#ef4444", "#dc2626"];
+                    addLine("fib" + idx, closes.map(() => val), colors[idx]);
+                });
+            } else { for (let i = 0; i < 7; i++) removeLine("fib" + i); }
+        };
+    }
+
+    const customBtn = document.getElementById("addCustomEma");
+    if (customBtn) {
+        customBtn.onclick = () => {
+            const period = parseInt(document.getElementById("customEmaPeriod").value);
+            if (period >= 2 && period <= 500) addLine("custom" + period, ema(closes, period), "#a78bfa");
+        };
+    }
+}
+
+// ══════════════ KEY METRICS ══════════════
+function renderKeyMetrics(data) {
+    const t = data.technicals || {};
+    const r = data.ratios || {};
+    const items = [
+        { label: "Price", value: fmtCurrency(t.price) },
+        { label: "RSI", value: fmt(t.rsi), cls: t.rsi > 70 ? "negative" : t.rsi < 30 ? "positive" : "" },
+        { label: "MACD", value: fmt(t.macd), cls: t.macd > t.macd_signal ? "positive" : "negative" },
+        { label: "SMA 200", value: fmtCurrency(t.sma_200) },
+        { label: "P/E", value: fmt(r.pe) },
+        { label: "EV/EBITDA", value: fmt(r.ev_ebitda) },
+        { label: "ROE", value: fmtPct(r.roe) },
+        { label: "ATR", value: fmtCurrency(t.atr) },
+    ];
+    document.getElementById("keyMetrics").innerHTML = items.map(i =>
+        `<div class="data-item"><div class="label">${i.label}</div><div class="value ${i.cls || ""}">${i.value}</div></div>`
+    ).join("");
+}
+
+// ══════════════ QUICK SIGNAL ══════════════
+function renderQuickSignal(data) {
+    const t = data.technicals || {};
+    let score = 0, reasons = [];
+    if (t.rsi < 30) { score += 2; reasons.push("RSI oversold"); }
+    else if (t.rsi > 70) { score -= 2; reasons.push("RSI overbought"); }
+    if (t.macd > t.macd_signal) { score += 1; reasons.push("MACD bullish"); }
+    else { score -= 1; reasons.push("MACD bearish"); }
+    if (t.price > t.sma_200) { score += 1; reasons.push("Above SMA200"); }
+    else if (t.sma_200) { score -= 1; reasons.push("Below SMA200"); }
+    if (t.price > t.ema_20) { score += 1; reasons.push("Above EMA20"); }
+
+    const cls = score >= 2 ? "bullish" : score <= -2 ? "bearish" : "neutral";
+    const label = score >= 2 ? "BULLISH" : score <= -2 ? "BEARISH" : "NEUTRAL";
+    document.getElementById("quickSignal").innerHTML = `
+        <div class="signal-box ${cls}">
+            <div class="signal-verdict ${cls}">${label}</div>
+            <div class="signal-reason">${reasons.join(" · ")}</div>
+        </div>`;
+}
+
+// ══════════════ TECHNICAL INDICATORS ══════════════
+function renderTechnicalIndicators(data) {
+    const t = data.technicals || {};
+    const items = [
+        { label: "EMA 5", value: fmtCurrency(t.ema_5) }, { label: "EMA 10", value: fmtCurrency(t.ema_10) },
+        { label: "EMA 20", value: fmtCurrency(t.ema_20) }, { label: "EMA 50", value: fmtCurrency(t.ema_50) },
+        { label: "SMA 200", value: fmtCurrency(t.sma_200) }, { label: "RSI (14)", value: fmt(t.rsi), cls: t.rsi > 70 ? "negative" : t.rsi < 30 ? "positive" : "" },
+        { label: "MACD", value: fmt(t.macd) }, { label: "MACD Signal", value: fmt(t.macd_signal) },
+        { label: "BB Upper", value: fmtCurrency(t.bb_upper) }, { label: "BB Lower", value: fmtCurrency(t.bb_lower) },
+        { label: "ATR (14)", value: fmtCurrency(t.atr) }, { label: "VWAP", value: fmtCurrency(t.vwap) },
+    ];
+    document.getElementById("technicalIndicators").innerHTML = items.map(i =>
+        `<div class="data-item"><div class="label">${i.label}</div><div class="value ${i.cls || ""}">${i.value}</div></div>`
+    ).join("");
+}
+
+// ══════════════ FINANCIALS ══════════════
+function renderFinancials(data) {
+    const f = data.financials || {}, r = data.ratios || {}, fc = data.fcff || {};
+    document.getElementById("incomeStatement").innerHTML = renderGrid(f, true);
+    document.getElementById("ratiosGrid").innerHTML = renderGrid(r, false);
+    document.getElementById("fcffGrid").innerHTML = renderGrid(fc, true);
+}
+function renderGrid(obj, asCurrency) {
+    return Object.entries(obj).map(([k, v]) => {
+        const label = k.replace(/_/g, " ").replace(/\b\w/g, c => c.toUpperCase());
+        const val = asCurrency && typeof v === "number" && Math.abs(v) > 100 ? fmtCurrencyLarge(v) : fmtVal(v);
+        return `<div class="data-item"><div class="label">${label}</div><div class="value">${val}</div></div>`;
+    }).join("");
+}
+
+// ══════════════ FETCH: CANDLESTICK PATTERNS (last 7 days + prediction) ══════════════
+async function fetchPatterns(ticker, prices) {
+    try {
+        const res = await fetch("/api/patterns", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker, prices, lookback_days: 7 }) });
+        const data = await res.json();
+        const el = document.getElementById("candlestickPatterns");
+        const outlookEl = document.getElementById("patternOutlook");
+
+        // Render outlook summary
+        if (data.outlook) {
+            const cls = data.outlook.startsWith("BULLISH") ? "bullish" : data.outlook.startsWith("BEARISH") ? "bearish" : "neutral";
+            outlookEl.className = "pattern-outlook-box " + cls;
+            outlookEl.innerHTML = `
+                <div>🔮 7-Day Pattern Outlook: ${data.outlook}</div>
+                <div class="pattern-outlook-sub">Bullish: ${data.bullish_count || 0} · Bearish: ${data.bearish_count || 0} · Neutral: ${data.neutral_count || 0}</div>`;
+        }
+
+        if (!data.patterns || !data.patterns.length) {
+            el.innerHTML = '<p style="color:var(--text-muted);font-style:italic;">No significant patterns detected in the last 7 trading days.</p>';
+            return;
+        }
+        el.innerHTML = data.patterns.map(p => `
+            <div class="pattern-card">
+                <span class="pattern-badge ${p.type}">${p.type}</span>
+                <div class="pattern-info">
+                    <h4>${p.pattern}</h4>
+                    <div class="date">${p.date}</div>
+                    <p>${p.description}</p>
+                    <div class="pattern-prediction">🔮 ${p.prediction || ""}</div>
+                </div>
+            </div>
+        `).join("");
+    } catch (e) { console.error("Patterns:", e); }
+}
+
+// ══════════════ FETCH: ANALYST RATINGS (N/A handling) ══════════════
+async function fetchAnalyst(ticker) {
+    try {
+        const res = await fetch("/api/analyst", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        const el = document.getElementById("analystRatings");
+
+        if (data.error || data.available === false) {
+            el.innerHTML = `<div class="analyst-na">📊 Analyst ratings are not available for ${ticker}.<br><small>This ticker may not be covered by Wall Street analysts on Finnhub.</small></div>`;
+            return;
+        }
+
+        const r = data.recommendation || {};
+        const total = (r.strong_buy || 0) + (r.buy || 0) + (r.hold || 0) + (r.sell || 0) + (r.strong_sell || 0) || 1;
+        const pt = data.price_target || {};
+
+        el.innerHTML = `
+            <div class="analyst-bars">
+                ${analystBar("Strong Buy", r.strong_buy, total, "buy")}
+                ${analystBar("Buy", r.buy, total, "buy")}
+                ${analystBar("Hold", r.hold, total, "hold")}
+                ${analystBar("Sell", r.sell, total, "sell")}
+                ${analystBar("Strong Sell", r.strong_sell, total, "sell")}
+            </div>
+            <div class="price-target-grid">
+                <div class="data-item"><div class="label">Target Low</div><div class="value negative">${pt.low !== "N/A" ? fmtCurrency(pt.low) : "N/A"}</div></div>
+                <div class="data-item"><div class="label">Target Mean</div><div class="value">${pt.mean !== "N/A" ? fmtCurrency(pt.mean) : "N/A"}</div></div>
+                <div class="data-item"><div class="label">Target Median</div><div class="value">${pt.median !== "N/A" ? fmtCurrency(pt.median) : "N/A"}</div></div>
+                <div class="data-item"><div class="label">Target High</div><div class="value positive">${pt.high !== "N/A" ? fmtCurrency(pt.high) : "N/A"}</div></div>
+            </div>`;
+    } catch (e) { console.error("Analyst:", e); }
+}
+function analystBar(label, count, total, cls) {
+    const pct = Math.round((count || 0) / total * 100);
+    return `<div class="analyst-bar-row">
+        <div class="analyst-bar-label">${label}</div>
+        <div class="analyst-bar-track"><div class="analyst-bar-fill ${cls}" style="width:${pct}%">${count || 0}</div></div>
+    </div>`;
+}
+
+// ══════════════ FETCH: INSIDER TRADING ══════════════
+async function fetchInsider(ticker) {
+    try {
+        const res = await fetch("/api/insider", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        const el = document.getElementById("insiderTrading");
+        if (!data.transactions || !data.transactions.length) { el.innerHTML = '<p style="color:var(--text-muted);">No recent insider transactions.</p>'; return; }
+        const rows = data.transactions.slice(0, 10).map(t => {
+            const isBuy = (t.change > 0 || t.transaction_type === "P - Purchase");
+            return `<tr><td>${t.filing_date}</td><td>${t.name}</td><td class="${isBuy ? 'positive' : 'negative'}">${t.transaction_type || (isBuy ? 'Buy' : 'Sell')}</td><td>${fmtNum(t.change)}</td></tr>`;
+        }).join("");
+        el.innerHTML = `<table class="insider-table"><thead><tr><th>Date</th><th>Insider</th><th>Type</th><th>Shares</th></tr></thead><tbody>${rows}</tbody></table>`;
+    } catch (e) { console.error("Insider:", e); }
+}
+
+// ══════════════ FETCH: MARKET SENTIMENT ══════════════
+async function fetchSentiment() {
+    try {
+        const res = await fetch("/api/sentiment-market", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) });
+        const data = await res.json();
+
+        const fg = data.fear_greed || {};
+        const fgVal = fg.value || 50;
+        const fgCls = fgVal < 25 ? "negative" : fgVal < 45 ? "muted" : fgVal < 55 ? "" : fgVal < 75 ? "" : "positive";
+        document.getElementById("fearGreedGauge").innerHTML = `
+            <div class="fg-gauge">
+                <div class="fg-value">${fgVal}</div>
+                <div class="fg-label ${fgCls}">${fg.description || "Neutral"}</div>
+                <div class="fg-bar"><div class="fg-marker" style="left:${fgVal}%"></div></div>
+            </div>`;
+
+        const vix = data.vix || {};
+        const vixCls = vix.value < 15 ? "positive" : vix.value < 25 ? "" : vix.value < 35 ? "muted" : "negative";
+        document.getElementById("vixDisplay").innerHTML = `
+            <div class="vix-display">
+                <div class="vix-value ${vixCls}">${vix.value || "N/A"}</div>
+                <div class="vix-label">${vix.label || ""}</div>
+            </div>`;
+    } catch (e) { console.error("Sentiment:", e); }
+}
+
+// ══════════════ FETCH: NEWS ══════════════
+async function fetchNews(ticker) {
+    try {
+        const res = await fetch("/api/news", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        newsData = await res.json();
+        const el = document.getElementById("newsSection");
+        if (!newsData.news || !newsData.news.length) { el.innerHTML = '<p style="color:var(--text-muted);">No recent news.</p>'; return; }
+
+        const avgCls = newsData.overall_label === "Positive" ? "positive" : newsData.overall_label === "Negative" ? "negative" : "neutral";
+        el.innerHTML = `<div class="sentiment-badge"><span class="sentiment-pill ${avgCls}">Overall: ${newsData.overall_label} (${newsData.average_sentiment})</span></div>` +
+            newsData.news.map(n => {
+                const cls = n.sentiment_label === "Positive" ? "positive" : n.sentiment_label === "Negative" ? "negative" : "neutral";
+                return `<div class="news-item"><div class="news-title"><a href="${n.link}" target="_blank">${n.title}</a></div>
+                    <div class="news-meta"><span class="sentiment-pill ${cls}">${n.sentiment_label} (${n.sentiment_score})</span><span>${n.source || ""}</span></div></div>`;
+            }).join("");
+    } catch (e) { console.error("News:", e); }
+}
+
+// ══════════════ FETCH: FRED MACRO (with good/bad + explanations) ══════════════
+async function fetchMacro() {
+    try {
+        const res = await fetch("/api/macro", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) });
+        const data = await res.json();
+        const el = document.getElementById("macroIndicators");
+        if (data.error) { el.innerHTML = `<p style="color:var(--text-muted);">${data.error}</p>`; return; }
+        el.innerHTML = Object.entries(data.indicators || {}).map(([k, v]) => {
+            const statusBadge = v.status ? `<span class="macro-status-badge ${v.status}">${v.status}</span>` : "";
+            const explanation = v.explanation ? `<div class="macro-explanation">${v.explanation}</div>` : "";
+            return `<div class="data-item macro-item">
+                <div class="label">${v.label} ${statusBadge}</div>
+                <div class="value">${v.value}</div>
+                ${explanation}
+            </div>`;
+        }).join("");
+    } catch (e) { console.error("Macro:", e); }
+}
+
+// ══════════════ FETCH: EARNINGS ══════════════
+async function fetchEarnings(ticker) {
+    try {
+        const res = await fetch("/api/earnings", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        const el = document.getElementById("earningsTable");
+        if (!data.earnings || !data.earnings.length) { el.innerHTML = '<p style="color:var(--text-muted);">No earnings data available.</p>'; return; }
+        const rows = data.earnings.map(e => {
+            const surprise = parseFloat(e.surprise_pct);
+            const cls = surprise > 0 ? "surprise-positive" : surprise < 0 ? "surprise-negative" : "";
+            return `<tr><td>${e.period}</td><td>${fmtCurrency(e.estimate)}</td><td>${fmtCurrency(e.actual)}</td><td class="${cls}">${fmtCurrency(e.surprise)}</td><td class="${cls}">${fmtPctRaw(e.surprise_pct)}</td></tr>`;
+        }).join("");
+        el.innerHTML = `<table class="earnings-table"><thead><tr><th>Period</th><th>Estimate</th><th>Actual</th><th>Surprise</th><th>Surprise %</th></tr></thead><tbody>${rows}</tbody></table>`;
+    } catch (e) { console.error("Earnings:", e); }
+}
+
+// ══════════════ FETCH: MONTE CARLO (selectable bands) ══════════════
+let mcChartInstance = null;
+let mcBandSeries = {};
+let mcRawData = null;
+
+async function fetchMonteCarlo(ticker, prices) {
+    try {
+        const res = await fetch("/api/monte-carlo", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker, prices, days: 60, simulations: 1000 }) });
+        mcRawData = await res.json();
+        if (mcRawData.error) { document.getElementById("monteCarloChart").innerHTML = `<p style="color:var(--text-muted);padding:20px;">${mcRawData.error}</p>`; return; }
+
+        analysisData._mc = mcRawData;
+        renderMCChart(mcRawData);
+        renderMCStats(mcRawData);
+        setupMCBandToggles();
+    } catch (e) { console.error("Monte Carlo:", e); }
+}
+
+function renderMCChart(data) {
+    const container = document.getElementById("monteCarloChart");
+    container.innerHTML = "";
+    mcBandSeries = {};
+
+    const cc = getChartColors();
+    mcChartInstance = LightweightCharts.createChart(container, {
+        layout: { background: { color: cc.bg }, textColor: cc.text },
+        grid: { vertLines: { color: cc.grid }, horzLines: { color: cc.grid } },
+        timeScale: { borderColor: cc.border }, rightPriceScale: { borderColor: cc.border },
+    });
+
+    const today = new Date();
+    function dayStr(offset) { const d = new Date(today); d.setDate(d.getDate() + offset); return d.toISOString().slice(0, 10); }
+
+    const bands = [
+        { key: "p90", color: "rgba(34,197,94,0.4)", label: "P90 (Bull)", lineWidth: 1 },
+        { key: "p75", color: "rgba(34,197,94,0.6)", label: "P75", lineWidth: 1 },
+        { key: "p50", color: "rgba(99,102,241,0.9)", label: "P50 (Median)", lineWidth: 2 },
+        { key: "p25", color: "rgba(239,68,68,0.6)", label: "P25", lineWidth: 1 },
+        { key: "p10", color: "rgba(239,68,68,0.4)", label: "P10 (Bear)", lineWidth: 1 },
+    ];
+
+    bands.forEach(b => {
+        if (data.percentiles && data.percentiles[b.key]) {
+            const series = mcChartInstance.addLineSeries({ color: b.color, lineWidth: b.lineWidth, priceLineVisible: false, lastValueVisible: false });
+            series.setData(data.percentiles[b.key].map((v, i) => ({ time: dayStr(i + 1), value: v })));
+            mcBandSeries[b.key] = series;
+        }
+    });
+    mcChartInstance.timeScale().fitContent();
+}
+
+function renderMCStats(data) {
+    const s = data.final_stats || {};
+    document.getElementById("monteCarloStats").innerHTML = [
+        { label: "Start Price", value: fmtCurrency(data.start_price) },
+        { label: "Median (P50)", value: fmtCurrency(s.median) },
+        { label: "Mean", value: fmtCurrency(s.mean) },
+        { label: "P10 (Bearish)", value: fmtCurrency(s.p10), cls: "negative" },
+        { label: "P90 (Bullish)", value: fmtCurrency(s.p90), cls: "positive" },
+    ].map(i => `<div class="data-item"><div class="label">${i.label}</div><div class="value ${i.cls || ""}">${i.value}</div></div>`).join("");
+}
+
+function setupMCBandToggles() {
+    const bandMap = { togP90: "p90", togP75: "p75", togP50: "p50", togP25: "p25", togP10: "p10" };
+    Object.entries(bandMap).forEach(([elId, bandKey]) => {
+        const el = document.getElementById(elId);
+        if (!el) return;
+        el.checked = true;
+        el.onchange = () => {
+            if (mcBandSeries[bandKey]) {
+                if (el.checked) {
+                    mcBandSeries[bandKey].applyOptions({ visible: true });
+                } else {
+                    mcBandSeries[bandKey].applyOptions({ visible: false });
+                }
+            }
+        };
+    });
+}
+
+// ══════════════ FETCH: DCF ══════════════
+async function fetchDCF(ticker) {
+    try {
+        const res = await fetch("/api/dcf", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        if (data.error) { document.getElementById("dcfValuation").innerHTML = `<p style="color:var(--text-muted);">${data.error}</p>`; return; }
+        analysisData._dcf = data;
+        renderDCFData(data);
+    } catch (e) { console.error("DCF:", e); }
+}
+function renderDCFData(data) {
+    const el = document.getElementById("dcfValuation");
+    const cls = data.verdict === "UNDERVALUED" ? "undervalued" : data.verdict === "OVERVALUED" ? "overvalued" : "fair";
+    const arrow = data.upside_pct > 0 ? "↑" : "↓";
+    el.innerHTML = `
+        <div class="dcf-hero">
+            <div class="dcf-verdict ${cls}">
+                ${data.verdict}
+                <div class="dcf-sub">${arrow} ${Math.abs(data.upside_pct)}% ${data.upside_pct > 0 ? 'upside' : 'downside'}</div>
+            </div>
+            <div class="dcf-metrics">
+                <div class="data-item"><div class="label">Intrinsic Value</div><div class="value positive">${fmtCurrency(data.intrinsic_value)}</div></div>
+                <div class="data-item"><div class="label">Current Price</div><div class="value">${fmtCurrency(data.current_price)}</div></div>
+                <div class="data-item"><div class="label">WACC</div><div class="value">${data.wacc}%</div></div>
+                <div class="data-item"><div class="label">Growth Rate</div><div class="value">${data.growth_rate}%</div></div>
+                <div class="data-item"><div class="label">Base FCF</div><div class="value">${fmtCurrencyLarge(data.base_fcf)}</div></div>
+                <div class="data-item"><div class="label">Enterprise Value</div><div class="value">${fmtCurrencyLarge(data.enterprise_value)}</div></div>
+            </div>
+        </div>`;
+}
+
+// ══════════════ FETCH: Z-SCORE ══════════════
+async function fetchZScore(ticker) {
+    try {
+        const res = await fetch("/api/zscore", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        const el = document.getElementById("zScore");
+        if (data.error) { el.innerHTML = `<p style="color:var(--text-muted);">${data.error}</p>`; return; }
+
+        const cls = data.zone === "Safe Zone" ? "safe" : data.zone === "Grey Zone" ? "grey" : "distress";
+        el.innerHTML = `
+            <div class="zscore-badge ${cls}">${data.z_score}<br><span style="font-size:14px;font-weight:500;">${data.zone}</span></div>
+            <div class="zscore-components">
+                ${Object.entries(data.components || {}).map(([k, v]) =>
+            `<div class="data-item"><div class="label">${k.replace(/_/g, " ")}</div><div class="value">${v}</div></div>`
+        ).join("")}
+            </div>`;
+    } catch (e) { console.error("ZScore:", e); }
+}
+
+// ══════════════ FETCH: DIVIDENDS ══════════════
+async function fetchDividends(ticker) {
+    try {
+        const res = await fetch("/api/dividends", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        if (data.error) { document.getElementById("dividendAnalysis").innerHTML = `<p style="color:var(--text-muted);">${data.error}</p>`; return; }
+        analysisData._dividends = data;
+        renderDividendData(data);
+    } catch (e) { console.error("Dividends:", e); }
+}
+function renderDividendData(data) {
+    const el = document.getElementById("dividendAnalysis");
+    const yld = data.dividend_yield && data.dividend_yield !== "N/A" ? (data.dividend_yield * 100).toFixed(2) + "%" : "N/A";
+    const payout = data.payout_ratio && data.payout_ratio !== "N/A" ? (data.payout_ratio * 100).toFixed(1) + "%" : "N/A";
+    el.innerHTML = `
+        <div class="dividend-grid">
+            <div class="data-item"><div class="label">Yield</div><div class="value positive">${yld}</div></div>
+            <div class="data-item"><div class="label">Annual Rate</div><div class="value">${fmtCurrency(data.dividend_rate)}</div></div>
+            <div class="data-item"><div class="label">Payout Ratio</div><div class="value">${payout}</div></div>
+            <div class="data-item"><div class="label">5Y Avg Yield</div><div class="value">${data.five_year_avg_yield !== "N/A" ? data.five_year_avg_yield + "%" : "N/A"}</div></div>
+        </div>`;
+}
+
+// ══════════════ FETCH: CORRELATION (FIXED) ══════════════
+async function fetchCorrelation(ticker) {
+    try {
+        const res = await fetch("/api/correlation", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        const el = document.getElementById("correlationMatrix");
+        if (data.error) { el.innerHTML = `<p style="color:var(--text-muted);">${data.error}</p>`; return; }
+
+        const tickers = data.tickers || [];
+        const m = data.matrix || {};
+        let html = '<table class="corr-table"><thead><tr><th></th>';
+        tickers.forEach(t => html += `<th>${t}</th>`);
+        html += '</tr></thead><tbody>';
+        tickers.forEach(row => {
+            html += `<tr><td><strong>${row}</strong></td>`;
+            tickers.forEach(col => {
+                const val = (m[col] && m[col][row] !== undefined) ? m[col][row] : 0;
+                const bg = corrColor(val);
+                html += `<td style="background:${bg};color:${Math.abs(val) > 0.5 ? 'white' : 'var(--text-secondary)'};font-weight:${Math.abs(val) > 0.7 ? '700' : '400'}">${val.toFixed(2)}</td>`;
+            });
+            html += '</tr>';
+        });
+        html += '</tbody></table>';
+        el.innerHTML = html;
+    } catch (e) { console.error("Correlation:", e); }
+}
+function corrColor(val) {
+    if (val >= 0) return `rgba(34,197,94,${Math.abs(val) * 0.6})`;
+    return `rgba(239,68,68,${Math.abs(val) * 0.6})`;
+}
+
+// ══════════════ FETCH: SECTOR HEATMAP ══════════════
+let heatmapData = null;
+async function fetchHeatmap() {
+    try {
+        const res = await fetch("/api/heatmap", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({}) });
+        heatmapData = await res.json();
+        if (heatmapData.error) { document.getElementById("sectorHeatmap").innerHTML = `<p style="color:var(--text-muted);">${heatmapData.error}</p>`; return; }
+
+        const controls = document.getElementById("heatmapControls");
+        controls.innerHTML = (heatmapData.timeframes || []).map((tf, i) =>
+            `<button class="heatmap-btn ${i === 0 ? 'active' : ''}" data-tf="${tf}">${tf}</button>`
+        ).join("");
+        controls.querySelectorAll(".heatmap-btn").forEach(btn => {
+            btn.addEventListener("click", () => {
+                controls.querySelectorAll(".heatmap-btn").forEach(b => b.classList.remove("active"));
+                btn.classList.add("active");
+                renderHeatmap(btn.dataset.tf);
+            });
+        });
+        if (heatmapData.timeframes && heatmapData.timeframes.length) renderHeatmap(heatmapData.timeframes[0]);
+    } catch (e) { console.error("Heatmap:", e); }
+}
+function renderHeatmap(tf) {
+    const sectors = heatmapData.sectors[tf] || {};
+    const entries = Object.entries(sectors);
+    if (!entries.length) {
+        document.getElementById("sectorHeatmap").innerHTML = '<p style="color:var(--text-muted);">Sector data temporarily unavailable (API rate limit).</p>';
+        return;
+    }
+    document.getElementById("sectorHeatmap").innerHTML = entries.map(([name, pct]) => {
+        const bg = pct >= 0 ? `rgba(34,197,94,${Math.min(Math.abs(pct) / 5, 0.7) + 0.1})` : `rgba(239,68,68,${Math.min(Math.abs(pct) / 5, 0.7) + 0.1})`;
+        const color = Math.abs(pct) > 1 ? "white" : "var(--text-secondary)";
+        return `<div class="heatmap-cell" style="background:${bg};color:${color}"><div class="sector-name">${name}</div><div class="sector-pct">${pct > 0 ? "+" : ""}${pct.toFixed(2)}%</div></div>`;
+    }).join("");
+}
+
+// ══════════════ FETCH: COMPETITORS (FIXED field names) ══════════════
+async function fetchCompetitors(ticker) {
+    try {
+        const res = await fetch("/api/competitors", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ ticker }) });
+        const data = await res.json();
+        const el = document.getElementById("compSection");
+        if (!data.peers || !data.peers.length) {
+            el.innerHTML = `<p style="color:var(--text-muted);">No competitor data available. <span class="badge-sector">${data.sector || "unknown"}</span></p>`;
+            if (data.error) el.innerHTML += `<p style="color:var(--text-muted);font-size:12px;margin-top:8px;">${data.error}</p>`;
+            return;
+        }
+
+        let html = `<p style="margin-bottom:10px;">Sector: <span class="badge-sector">${data.sector}</span></p>`;
+        html += '<table class="comp-table"><thead><tr><th>Ticker</th><th>Market Cap</th><th>P/E</th><th>EV/EBITDA</th><th>ROE</th><th>Net Margin</th><th>Gross Margin</th></tr></thead><tbody>';
+        data.peers.forEach(p => {
+            const cls = p.is_target ? ' class="comp-target"' : '';
+            html += `<tr${cls}>
+                <td><strong>${p.ticker}</strong></td>
+                <td>${fmtCurrencyLarge(p.market_cap)}</td>
+                <td>${fmtVal(p.pe_ratio)}</td>
+                <td>${fmtVal(p.ev_ebitda)}</td>
+                <td>${fmtPctVal(p.roe)}</td>
+                <td>${fmtPctVal(p.net_margin)}</td>
+                <td>${fmtPctVal(p.gross_margin)}</td>
+            </tr>`;
+        });
+        html += '</tbody></table>';
+        el.innerHTML = html;
+    } catch (e) { console.error("Competitors:", e); }
+}
+
+// ══════════════ FETCH: AI ══════════════
+async function fetchAI(ticker) {
+    try {
+        const payload = { ticker, analysis: analysisData || {}, news: newsData || {} };
+        const res = await fetch("/api/ai", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) });
+        const data = await res.json();
+        document.getElementById("aiContent").innerHTML = data.overview ? formatAI(data.overview) : `<p class="ai-placeholder">${data.error || "No response"}</p>`;
+    } catch (e) { document.getElementById("aiContent").innerHTML = '<p class="ai-placeholder">AI unavailable.</p>'; }
+}
+
+document.getElementById("askAi").addEventListener("click", async () => {
+    const q = document.getElementById("aiInput").value.trim();
+    if (!q || !currentTicker) return;
+    document.getElementById("aiContent").innerHTML = '<p class="ai-placeholder">Thinking...</p>';
+    try {
+        const payload = { ticker: currentTicker, analysis: analysisData || {}, news: newsData || {}, question: q };
+        const res = await fetch("/api/ai", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) });
+        const data = await res.json();
+        document.getElementById("aiContent").innerHTML = data.overview ? formatAI(data.overview) : `<p class="ai-placeholder">${data.error || "No response"}</p>`;
+    } catch (e) { document.getElementById("aiContent").innerHTML = '<p class="ai-placeholder">Error.</p>'; }
+});
+
+function formatAI(text) {
+    return text.replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+        .replace(/^### (.*?)$/gm, '<h4>$1</h4>')
+        .replace(/^## (.*?)$/gm, '<h3>$1</h3>')
+        .replace(/^# (.*?)$/gm, '<h2>$1</h2>')
+        .replace(/\n- /g, '\n• ')
+        .replace(/\n/g, '<br>');
+}
+
+// ══════════════ EXPORT ══════════════
+document.getElementById("exportBtnSidebar").addEventListener("click", async () => {
+    if (!currentTicker || !analysisData) return;
+    try {
+        const payload = { ticker: currentTicker, analysis: analysisData, news: newsData || {}, ai_overview: document.getElementById("aiContent").innerText || "" };
+        const res = await fetch("/api/export", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify(payload) });
+        const blob = await res.blob();
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a"); a.href = url; a.download = `${currentTicker}_analysis.xlsx`; a.click();
+    } catch (e) { alert("Export failed."); }
+});
+
+// ══════════════ FORMATTING HELPERS ══════════════
+function fmt(v) { if (v === null || v === undefined || v === "N/A") return "N/A"; return typeof v === "number" ? v.toFixed(2) : String(v); }
+function fmtPct(v) { if (v === null || v === undefined || v === "N/A") return "N/A"; return (v * 100).toFixed(2) + "%"; }
+function fmtPctRaw(v) { if (v === null || v === undefined || v === "N/A") return "N/A"; return parseFloat(v).toFixed(2) + "%"; }
+function fmtVal(v) { if (v === null || v === undefined || v === "N/A") return "N/A"; return typeof v === "number" ? v.toLocaleString(undefined, { maximumFractionDigits: 2 }) : String(v); }
+function fmtPctVal(v) { if (v === null || v === undefined || v === "N/A") return "N/A"; return typeof v === "number" ? (v * 100).toFixed(2) + "%" : String(v); }
+function fmtNum(v) { if (v === null || v === undefined || v === "N/A") return "N/A"; return Number(v).toLocaleString(); }
+function fmtLarge(v) {
+    if (v === null || v === undefined || v === "N/A") return "N/A";
+    const n = Number(v);
+    if (isNaN(n)) return String(v);
+    if (Math.abs(n) >= 1e12) return (n / 1e12).toFixed(2) + "T";
+    if (Math.abs(n) >= 1e9) return (n / 1e9).toFixed(2) + "B";
+    if (Math.abs(n) >= 1e6) return (n / 1e6).toFixed(2) + "M";
+    if (Math.abs(n) >= 1e3) return (n / 1e3).toFixed(1) + "K";
+    return n.toFixed(2);
+}
+function fmtCurrencyLarge(v) {
+    if (v === null || v === undefined || v === "N/A") return "N/A";
+    const converted = convertCurrency(v);
+    if (converted === "N/A") return "N/A";
+    const sym = currencySymbols[currentCurrency];
+    const n = Number(converted);
+    if (isNaN(n)) return String(v);
+    if (Math.abs(n) >= 1e12) return sym + (n / 1e12).toFixed(2) + "T";
+    if (Math.abs(n) >= 1e9) return sym + (n / 1e9).toFixed(2) + "B";
+    if (Math.abs(n) >= 1e6) return sym + (n / 1e6).toFixed(2) + "M";
+    if (Math.abs(n) >= 1e3) return sym + (n / 1e3).toFixed(1) + "K";
+    return sym + n.toFixed(2);
+}
+
+// ══════════════ LIVE PRICE AUTO-REFRESH (15s) ══════════════
+let livePollInterval = null;
+
+function startLivePolling() {
+    stopLivePolling();
+    livePollInterval = setInterval(async () => {
+        if (!currentTicker) return;
+        try {
+            const res = await fetch("/api/live-price", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ ticker: currentTicker })
+            });
+            const data = await res.json();
+            if (data.price && analysisData && analysisData.technicals) {
+                analysisData.technicals.price = data.price;
+                // Update the price display in Key Metrics
+                const priceEl = document.querySelector("#keyMetrics .data-item .data-value");
+                if (priceEl) {
+                    priceEl.textContent = fmtCurrency(data.price);
+                    priceEl.classList.add("price-flash");
+                    setTimeout(() => priceEl.classList.remove("price-flash"), 600);
+                }
+                // Update last candle on chart if available
+                if (candleSeries && data.price) {
+                    const now = new Date();
+                    const todayStr = now.toISOString().slice(0, 10);
+                    candleSeries.update({
+                        time: todayStr,
+                        open: data.price,
+                        high: data.price,
+                        low: data.price,
+                        close: data.price,
+                    });
+                }
+            }
+        } catch (e) { /* silent fail for polling */ }
+    }, 15000);
+}
+
+function stopLivePolling() {
+    if (livePollInterval) {
+        clearInterval(livePollInterval);
+        livePollInterval = null;
+    }
+}
+
+// Start polling after each analysis
+const origRunAnalysis = runAnalysis;
+
+// ══════════════ OPTIONS CHAIN ══════════════
+let optionsChainData = null;
+let showCallsOrPuts = 'calls';
+
+async function loadOptionsChainForTicker(ticker) {
+    try {
+        const res = await fetch("/api/options/chain", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ticker })
+        });
+        optionsChainData = await res.json();
+        if (optionsChainData.error) {
+            document.getElementById("optionsChainTable").innerHTML = `<p class="ai-placeholder">${optionsChainData.error}</p>`;
+            return;
+        }
+        // Populate expiry selector
+        const sel = document.getElementById("optExpiry");
+        sel.innerHTML = (optionsChainData.expirations || []).map(e => `<option value="${e}" ${e === optionsChainData.expiration ? 'selected' : ''}>${e}</option>`).join("");
+        // Set payoff strike default to current price
+        if (optionsChainData.current_price) {
+            document.getElementById("payoffStrike").value = Math.round(optionsChainData.current_price);
+        }
+        renderOptionsChain();
+    } catch (e) {
+        document.getElementById("optionsChainTable").innerHTML = `<p class="ai-placeholder">Failed to load options chain</p>`;
+    }
+}
+
+function renderOptionsChain() {
+    if (!optionsChainData) return;
+    const data = showCallsOrPuts === 'calls' ? optionsChainData.calls : optionsChainData.puts;
+    if (!data || !data.length) {
+        document.getElementById("optionsChainTable").innerHTML = `<p class="ai-placeholder">No data available</p>`;
+        return;
+    }
+    const curPrice = optionsChainData.current_price || 0;
+    let html = `<table class="data-table"><thead><tr>
+        <th>Strike</th><th>Last</th><th>Bid</th><th>Ask</th><th>Volume</th><th>OI</th><th>IV</th>
+        <th>Delta</th><th>Gamma</th><th>Theta</th><th>Vega</th>
+    </tr></thead><tbody>`;
+    for (const opt of data) {
+        const itm = (showCallsOrPuts === 'calls' && opt.strike < curPrice) || (showCallsOrPuts === 'puts' && opt.strike > curPrice);
+        const cls = itm ? ' class="positive"' : '';
+        html += `<tr${cls}>
+            <td><strong>${opt.strike}</strong></td>
+            <td>${(opt.lastPrice || 0).toFixed(2)}</td>
+            <td>${(opt.bid || 0).toFixed(2)}</td>
+            <td>${(opt.ask || 0).toFixed(2)}</td>
+            <td>${(opt.volume || 0).toLocaleString()}</td>
+            <td>${(opt.openInterest || 0).toLocaleString()}</td>
+            <td>${((opt.impliedVolatility || 0) * 100).toFixed(1)}%</td>
+            <td>${(opt.delta || 0).toFixed(4)}</td>
+            <td>${(opt.gamma || 0).toFixed(6)}</td>
+            <td>${(opt.theta || 0).toFixed(4)}</td>
+            <td>${(opt.vega || 0).toFixed(4)}</td>
+        </tr>`;
+    }
+    html += '</tbody></table>';
+    document.getElementById("optionsChainTable").innerHTML = html;
+}
+
+// Options chain button events
+document.getElementById("loadChainBtn")?.addEventListener("click", async () => {
+    if (!currentTicker) return;
+    const exp = document.getElementById("optExpiry").value;
+    try {
+        const res = await fetch("/api/options/chain", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ticker: currentTicker, expiration: exp })
+        });
+        optionsChainData = await res.json();
+        renderOptionsChain();
+    } catch (e) { console.error(e); }
+});
+
+document.querySelectorAll('[data-chain]').forEach(btn => {
+    btn.addEventListener('click', () => {
+        document.querySelectorAll('[data-chain]').forEach(b => b.classList.remove('active'));
+        btn.classList.add('active');
+        showCallsOrPuts = btn.dataset.chain;
+        renderOptionsChain();
+    });
+});
+
+// Payoff Diagram
+let payoffChartInstance = null;
+document.getElementById("drawPayoffBtn")?.addEventListener("click", async () => {
+    const strike = parseFloat(document.getElementById("payoffStrike").value) || 100;
+    const premium = parseFloat(document.getElementById("payoffPremium").value) || 5;
+    const optType = document.getElementById("payoffType").value;
+    const dir = document.getElementById("payoffDirection").value;
+    const curPrice = optionsChainData?.current_price || strike;
+    try {
+        const res = await fetch("/api/options/payoff", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ strike, premium, option_type: optType, is_long: dir === 'long', current_price: curPrice })
+        });
+        const data = await res.json();
+        renderPayoffChart(data.points, strike);
+    } catch (e) { console.error(e); }
+});
+
+function renderPayoffChart(points, strike) {
+    const container = document.getElementById("payoffChart");
+    container.innerHTML = "";
+    if (payoffChartInstance) { payoffChartInstance.remove(); payoffChartInstance = null; }
+    const cc = getChartColors();
+    payoffChartInstance = LightweightCharts.createChart(container, {
+        width: container.clientWidth || 600, height: 300,
+        layout: { background: { color: cc.bg }, textColor: cc.text },
+        grid: { vertLines: { color: cc.grid }, horzLines: { color: cc.grid } },
+        rightPriceScale: { borderColor: cc.border },
+    });
+    const series = payoffChartInstance.addLineSeries({ color: '#6366f1', lineWidth: 2 });
+    const d = points.map((p, i) => ({ time: i + 1, value: p.profit }));
+    series.setData(d);
+    // Add zero line
+    const zeroLine = payoffChartInstance.addLineSeries({ color: 'rgba(255,255,255,0.2)', lineWidth: 1, lineStyle: 2 });
+    zeroLine.setData(d.map(p => ({ time: p.time, value: 0 })));
+    payoffChartInstance.timeScale().fitContent();
+}
+
+
+// ══════════════ MARKET DASHBOARD ══════════════
+async function loadMarketDashboard() {
+    try {
+        const res = await fetch("/api/market-summary");
+        const data = await res.json();
+        if (data.error) { console.error(data.error); return; }
+        renderMarketCards("dashIndices", data.indices || []);
+        renderMarketCards("dashCommodities", data.commodities || []);
+        renderMarketCards("dashCurrencies", data.currencies || []);
+    } catch (e) { console.error("Market dashboard failed:", e); }
+}
+
+function renderMarketCards(containerId, items) {
+    const container = document.getElementById(containerId);
+    if (!container || !items.length) return;
+    container.innerHTML = items.map(item => {
+        const sign = item.change >= 0 ? '+' : '';
+        const cls = item.change >= 0 ? 'positive' : 'negative';
+        const arrow = item.change >= 0 ? '▲' : '▼';
+        return `<div class="market-card">
+            <div class="mc-name">${item.name}</div>
+            <div class="mc-price" data-target="${item.price}">${item.price > 0 ? item.price.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 }) : '—'}</div>
+            <div class="mc-change ${cls}">${arrow} ${sign}${item.change.toFixed(2)} (${sign}${item.change_pct.toFixed(2)}%)</div>
+        </div>`;
+    }).join('');
+    // Animate counters
+    container.querySelectorAll('.mc-price[data-target]').forEach(el => {
+        animateCounter(el, parseFloat(el.dataset.target));
+    });
+}
+
+function animateCounter(el, target) {
+    if (!target || target <= 0) return;
+    const duration = 800;
+    const start = performance.now();
+    const startVal = 0;
+    function tick(now) {
+        const elapsed = now - start;
+        const progress = Math.min(elapsed / duration, 1);
+        const eased = 1 - Math.pow(1 - progress, 3); // easeOutCubic
+        const current = startVal + (target - startVal) * eased;
+        el.textContent = current.toLocaleString(undefined, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+        if (progress < 1) requestAnimationFrame(tick);
+    }
+    requestAnimationFrame(tick);
+}
+
+// Auto-refresh dashboard every 60s
+let dashboardInterval = null;
+function startDashboardRefresh() {
+    if (dashboardInterval) clearInterval(dashboardInterval);
+    loadMarketDashboard();
+    dashboardInterval = setInterval(loadMarketDashboard, 60000);
+}
+
+// ══════════════ PORTFOLIO ══════════════
+let equityCurveChart = null;
+
+async function loadPortfolio() {
+    try {
+        const res = await fetch("/api/portfolio");
+        const data = await res.json();
+        if (data.error) { console.error(data.error); return; }
+        renderPortfolioSummary(data);
+        renderPositionsTable(data.positions);
+        renderPendingOrders(data.pending_orders || []);
+        loadPortfolioAnalytics();
+        loadTransactionHistory();
+        loadEquityCurve();
+    } catch (e) { console.error("Portfolio load failed:", e); }
+}
+
+function renderPortfolioSummary(data) {
+    const fmt = (v) => '$' + v.toLocaleString(undefined, { minimumFractionDigits: 2 });
+    const pnlClass = data.total_pnl >= 0 ? 'positive' : 'negative';
+
+    document.getElementById("pfTotalValue").textContent = fmt(data.total_value);
+    document.getElementById("pfCash").textContent = fmt(data.cash);
+    const bpEl = document.getElementById("pfBuyingPower");
+    if (bpEl) bpEl.textContent = fmt(data.buying_power || data.cash);
+    document.getElementById("pfPositionsValue").textContent = fmt(data.positions_value);
+    const muEl = document.getElementById("pfMarginUsed");
+    if (muEl) muEl.textContent = fmt(data.margin_used || 0);
+    const pnlEl = document.getElementById("pfPnL");
+    pnlEl.textContent = (data.total_pnl >= 0 ? '+' : '') + fmt(data.total_pnl);
+    pnlEl.className = 'data-value ' + pnlClass;
+    const retEl = document.getElementById("pfReturnPct");
+    retEl.textContent = (data.total_pnl_pct >= 0 ? '+' : '') + data.total_pnl_pct.toFixed(2) + '%';
+    retEl.className = 'data-value ' + pnlClass;
+
+    // Update badges
+    const slipEl = document.getElementById("pfSlippageLabel");
+    if (slipEl && data.slippage_bps !== undefined) slipEl.textContent = `Slip: ${data.slippage_bps} bps`;
+    const commEl = document.getElementById("pfCommLabel");
+    if (commEl && data.commission_per_share !== undefined) commEl.textContent = `Comm: $${data.commission_per_share}/sh`;
+}
+
+function renderPositionsTable(positions) {
+    const container = document.getElementById("positionsTable");
+    if (!positions || !positions.length) {
+        container.innerHTML = '<p class="ai-placeholder">No open positions. Use the Trade Terminal to buy your first asset.</p>';
+        return;
+    }
+    let html = `<table class="data-table"><thead><tr>
+        <th>Ticker</th><th>Side</th><th>Type</th><th>Shares</th><th>Avg Cost</th><th>Current</th><th>Value</th><th>P&L</th><th>P&L %</th><th>Alloc %</th>
+    </tr></thead><tbody>`;
+    for (const p of positions) {
+        const pnlClass = p.pnl >= 0 ? 'positive' : 'negative';
+        const sideClass = p.side === 'LONG' ? 'positive' : 'negative';
+        html += `<tr>
+            <td><strong>${p.ticker}</strong></td>
+            <td class="${sideClass}">${p.side}</td>
+            <td>${p.asset_type}</td>
+            <td>${p.shares}</td>
+            <td>$${p.avg_cost.toFixed(2)}</td>
+            <td>$${p.current_price.toFixed(2)}</td>
+            <td>$${p.market_value.toLocaleString(undefined, { minimumFractionDigits: 2 })}</td>
+            <td class="${pnlClass}">${p.pnl >= 0 ? '+' : ''}$${p.pnl.toFixed(2)}</td>
+            <td class="${pnlClass}">${p.pnl_pct >= 0 ? '+' : ''}${p.pnl_pct.toFixed(2)}%</td>
+            <td>${p.allocation_pct.toFixed(1)}%</td>
+        </tr>`;
+    }
+    html += '</tbody></table>';
+    container.innerHTML = html;
+}
+
+function renderPendingOrders(orders) {
+    const container = document.getElementById("pendingOrdersTable");
+    if (!container) return;
+    if (!orders || !orders.length) {
+        container.innerHTML = '<p class="ai-placeholder">No pending orders.</p>';
+        return;
+    }
+    let html = `<table class="data-table"><thead><tr>
+        <th>ID</th><th>Type</th><th>Side</th><th>Ticker</th><th>Shares</th><th>Target Price</th><th>Created</th><th>Action</th>
+    </tr></thead><tbody>`;
+    for (const o of orders) {
+        html += `<tr>
+            <td>#${o.id}</td>
+            <td>${o.order_type}</td>
+            <td class="${o.side === 'BUY' ? 'positive' : 'negative'}">${o.side}</td>
+            <td><strong>${o.ticker}</strong></td>
+            <td>${o.shares}</td>
+            <td>$${o.target_price.toFixed(2)}</td>
+            <td>${o.created_at}</td>
+            <td><button class="btn-sm btn-danger" onclick="cancelPendingOrder(${o.id})">Cancel</button></td>
+        </tr>`;
+    }
+    html += '</tbody></table>';
+    container.innerHTML = html;
+}
+
+async function cancelPendingOrder(orderId) {
+    try {
+        await fetch("/api/portfolio/cancel-order", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ order_id: orderId })
+        });
+        loadPortfolio();
+    } catch (e) { console.error(e); }
+}
+
+async function loadEquityCurve() {
+    try {
+        const res = await fetch("/api/portfolio/equity-curve");
+        const data = await res.json();
+        if (!data.curve || data.curve.length < 2) return;
+
+        const container = document.getElementById("equityCurveContainer");
+        if (!container) return;
+
+        if (equityCurveChart) {
+            equityCurveChart.remove();
+            equityCurveChart = null;
+        }
+
+        const isDark = document.documentElement.getAttribute('data-theme') !== 'light';
+        equityCurveChart = LightweightCharts.createChart(container, {
+            width: container.clientWidth,
+            height: 260,
+            layout: { background: { type: 'solid', color: 'transparent' }, textColor: isDark ? '#94a3b8' : '#64748b' },
+            grid: { vertLines: { visible: false }, horzLines: { color: isDark ? 'rgba(255,255,255,0.04)' : 'rgba(0,0,0,0.06)' } },
+            rightPriceScale: { borderVisible: false },
+            timeScale: { borderVisible: false },
+        });
+
+        const series = equityCurveChart.addAreaSeries({
+            topColor: 'rgba(99,102,241,0.3)',
+            bottomColor: 'rgba(99,102,241,0.02)',
+            lineColor: '#6366f1',
+            lineWidth: 2,
+        });
+
+        const chartData = data.curve.map((pt, i) => ({
+            time: pt.timestamp.split('T')[0] || pt.timestamp.split(' ')[0],
+            value: pt.total_value
+        }));
+
+        // Deduplicate by time (keep last)
+        const seen = {};
+        const uniqueData = [];
+        for (const d of chartData) {
+            seen[d.time] = d;
+        }
+        for (const key of Object.keys(seen).sort()) {
+            uniqueData.push(seen[key]);
+        }
+
+        if (uniqueData.length >= 2) {
+            series.setData(uniqueData);
+            equityCurveChart.timeScale().fitContent();
+        }
+
+        new ResizeObserver(() => {
+            equityCurveChart?.applyOptions({ width: container.clientWidth });
+        }).observe(container);
+    } catch (e) { console.error("Equity curve:", e); }
+}
+
+async function loadPortfolioAnalytics() {
+    try {
+        const res = await fetch("/api/portfolio/analytics");
+        const data = await res.json();
+        const container = document.getElementById("portfolioAnalytics");
+        container.innerHTML = `
+            <div class="data-grid">
+                <div class="data-item"><div class="data-label">Sharpe Ratio</div><div class="data-value">${data.sharpe_ratio}</div></div>
+                <div class="data-item"><div class="data-label">Sortino Ratio</div><div class="data-value">${data.sortino_ratio || 0}</div></div>
+                <div class="data-item"><div class="data-label">Calmar Ratio</div><div class="data-value">${data.calmar_ratio || 0}</div></div>
+                <div class="data-item"><div class="data-label">Profit Factor</div><div class="data-value">${data.profit_factor || 0}</div></div>
+                <div class="data-item"><div class="data-label">Max Drawdown</div><div class="data-value negative">${data.max_drawdown_pct}%</div></div>
+                <div class="data-item"><div class="data-label">Win Rate</div><div class="data-value">${data.win_rate}%</div></div>
+                <div class="data-item"><div class="data-label">Total Trades</div><div class="data-value">${data.total_trades}</div></div>
+                <div class="data-item"><div class="data-label">Winning</div><div class="data-value positive">${data.winning_trades}</div></div>
+                <div class="data-item"><div class="data-label">Losing</div><div class="data-value negative">${data.losing_trades}</div></div>
+                <div class="data-item"><div class="data-label">Avg Win</div><div class="data-value positive">$${data.avg_win}</div></div>
+                <div class="data-item"><div class="data-label">Avg Loss</div><div class="data-value negative">$${data.avg_loss}</div></div>
+                <div class="data-item"><div class="data-label">Best Trade</div><div class="data-value positive">$${data.best_trade}</div></div>
+                <div class="data-item"><div class="data-label">Worst Trade</div><div class="data-value negative">$${data.worst_trade}</div></div>
+                <div class="data-item"><div class="data-label">Gross Profit</div><div class="data-value positive">$${data.gross_profit || 0}</div></div>
+                <div class="data-item"><div class="data-label">Gross Loss</div><div class="data-value negative">$${data.gross_loss || 0}</div></div>
+                <div class="data-item"><div class="data-label">Total Commission</div><div class="data-value">${data.total_commission || 0}</div></div>
+                <div class="data-item"><div class="data-label">Total Slippage</div><div class="data-value">${data.total_slippage || 0}</div></div>
+                <div class="data-item"><div class="data-label">Total Return</div><div class="data-value ${data.total_return_pct >= 0 ? 'positive' : 'negative'}">${data.total_return_pct}%</div></div>
+            </div>
+        `;
+    } catch (e) { console.error(e); }
+}
+
+async function loadTransactionHistory() {
+    try {
+        const res = await fetch("/api/portfolio/history");
+        const data = await res.json();
+        const container = document.getElementById("transactionHistory");
+        if (!data.transactions || !data.transactions.length) {
+            container.innerHTML = '<p class="ai-placeholder">No transactions yet.</p>';
+            return;
+        }
+        let html = `<table class="data-table"><thead><tr>
+            <th>Date</th><th>Action</th><th>Side</th><th>Ticker</th><th>Shares</th><th>Price</th><th>Slip</th><th>Comm</th><th>Total</th><th>P&L</th>
+        </tr></thead><tbody>`;
+        for (const t of data.transactions) {
+            const actionColors = { BUY: 'positive', SELL: 'negative', SHORT: 'negative', COVER: 'positive' };
+            const actionClass = actionColors[t.action] || '';
+            const pnlStr = t.pnl != null ? `<span class="${t.pnl >= 0 ? 'positive' : 'negative'}">${t.pnl >= 0 ? '+' : ''}$${t.pnl.toFixed(2)}</span>` : '—';
+            html += `<tr>
+                <td>${t.timestamp}</td>
+                <td class="${actionClass}"><strong>${t.action}</strong></td>
+                <td>${t.side || 'LONG'}</td>
+                <td>${t.ticker}</td>
+                <td>${t.shares}</td>
+                <td>$${t.price.toFixed(4)}</td>
+                <td>$${(t.slippage || 0).toFixed(4)}</td>
+                <td>$${(t.commission || 0).toFixed(2)}</td>
+                <td>$${t.total.toFixed(2)}</td>
+                <td>${pnlStr}</td>
+            </tr>`;
+        }
+        html += '</tbody></table>';
+        container.innerHTML = html;
+    } catch (e) { console.error(e); }
+}
+
+// ── Trade Terminal Controls ──────────────────────
+
+// Order type toggle: show/hide limit price field
+document.getElementById("tradeOrderType")?.addEventListener("change", (e) => {
+    const priceField = document.getElementById("tradeLimitPrice");
+    if (priceField) {
+        priceField.style.display = (e.target.value === 'market') ? 'none' : '';
+    }
+});
+
+// Trade search autocomplete
+let tradeSearchTimeout = null;
+document.getElementById("tradeTicker")?.addEventListener("input", async (e) => {
+    const q = e.target.value.trim();
+    const dropdown = document.getElementById("tradeDropdown");
+    if (!dropdown) return;
+    if (q.length < 1) { dropdown.classList.remove("open"); return; }
+
+    clearTimeout(tradeSearchTimeout);
+    tradeSearchTimeout = setTimeout(async () => {
+        try {
+            const res = await fetch(`/api/suggest?q=${encodeURIComponent(q)}`);
+            const results = await res.json();
+            if (!results.length) { dropdown.classList.remove("open"); return; }
+            dropdown.innerHTML = results.slice(0, 8).map(r =>
+                `<div class="trade-dropdown-item" data-ticker="${r.ticker}">
+                    <span class="ticker-sym">${r.ticker}</span>
+                    <span class="ticker-name">${r.name}</span>
+                </div>`
+            ).join('');
+            dropdown.classList.add("open");
+
+            dropdown.querySelectorAll('.trade-dropdown-item').forEach(item => {
+                item.addEventListener('click', () => {
+                    document.getElementById("tradeTicker").value = item.dataset.ticker;
+                    dropdown.classList.remove("open");
+                });
+            });
+        } catch (e) { dropdown.classList.remove("open"); }
+    }, 250);
+});
+
+// Close dropdown on outside click
+document.addEventListener('click', (e) => {
+    const dropdown = document.getElementById("tradeDropdown");
+    const input = document.getElementById("tradeTicker");
+    if (dropdown && !dropdown.contains(e.target) && e.target !== input) {
+        dropdown.classList.remove("open");
+    }
+});
+
+// Helper to get trade params
+function getTradeParams() {
+    const ticker = document.getElementById("tradeTicker").value.trim().toUpperCase();
+    const shares = parseFloat(document.getElementById("tradeShares").value);
+    const assetType = document.getElementById("tradeAssetType").value;
+    const orderType = document.getElementById("tradeOrderType")?.value || 'market';
+    const limitPrice = parseFloat(document.getElementById("tradeLimitPrice")?.value) || 0;
+    return { ticker, shares, assetType, orderType, limitPrice };
+}
+
+async function executeTrade(action) {
+    const { ticker, shares, assetType, orderType, limitPrice } = getTradeParams();
+    const resultEl = document.getElementById("tradeResult");
+    if (!ticker || !shares || shares <= 0) {
+        resultEl.innerHTML = '<span class="negative">Enter a valid ticker and quantity</span>';
+        return;
+    }
+
+    // Handle limit/stop orders
+    if (orderType !== 'market' && (action === 'buy' || action === 'sell')) {
+        if (limitPrice <= 0) {
+            resultEl.innerHTML = '<span class="negative">Enter a valid price for limit/stop order</span>';
+            return;
+        }
+        const endpoint = orderType === 'limit' ? '/api/portfolio/limit-order' : '/api/portfolio/stop-order';
+        resultEl.innerHTML = '<span>Placing order...</span>';
+        try {
+            const res = await fetch(endpoint, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    ticker, shares, price: limitPrice,
+                    side: action === 'buy' ? 'BUY' : 'SELL',
+                    asset_type: assetType
+                })
+            });
+            const data = await res.json();
+            if (data.error) {
+                resultEl.innerHTML = `<span class="negative">${data.error}</span>`;
+            } else {
+                resultEl.innerHTML = `<span class="positive">${orderType.toUpperCase()} order placed: ${data.side} ${data.shares} ${data.ticker} @ $${data.target_price}</span>`;
+                loadPortfolio();
+            }
+        } catch (e) { resultEl.innerHTML = `<span class="negative">Error: ${e.message}</span>`; }
+        return;
+    }
+
+    // Market orders
+    const endpoints = {
+        buy: '/api/portfolio/buy',
+        sell: '/api/portfolio/sell',
+        short: '/api/portfolio/short',
+        cover: '/api/portfolio/cover'
+    };
+    resultEl.innerHTML = '<span>Processing...</span>';
+    try {
+        const res = await fetch(endpoints[action], {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ ticker, shares, asset_type: assetType })
+        });
+        const data = await res.json();
+        if (data.error) {
+            resultEl.innerHTML = `<span class="negative">${data.error}</span>`;
+        } else {
+            const labels = { buy: 'Bought', sell: 'Sold', short: 'Shorted', cover: 'Covered' };
+            let msg = `${labels[action]} ${data.shares} ${data.ticker} @ $${data.price.toFixed(2)}`;
+            if (data.commission) msg += ` | Comm: $${data.commission.toFixed(2)}`;
+            if (data.pnl !== undefined) msg += ` | P&L: <span class="${data.pnl >= 0 ? 'positive' : 'negative'}">${data.pnl >= 0 ? '+' : ''}$${data.pnl.toFixed(2)}</span>`;
+            resultEl.innerHTML = `<span class="positive">${msg}</span>`;
+            loadPortfolio();
+        }
+    } catch (e) { resultEl.innerHTML = `<span class="negative">Error: ${e.message}</span>`; }
+}
+
+// Button handlers
+document.getElementById("buyBtn")?.addEventListener("click", () => executeTrade('buy'));
+document.getElementById("sellBtn")?.addEventListener("click", () => executeTrade('sell'));
+document.getElementById("shortBtn")?.addEventListener("click", () => executeTrade('short'));
+document.getElementById("coverBtn")?.addEventListener("click", () => executeTrade('cover'));
+
+// Reset portfolio
+document.getElementById("resetPortfolioBtn")?.addEventListener("click", async () => {
+    if (!confirm("Reset portfolio to $100,000? All positions, orders, and history will be deleted.")) return;
+    try {
+        await fetch("/api/portfolio/reset", { method: "POST" });
+        loadPortfolio();
+    } catch (e) { console.error(e); }
+});
+
+// Load portfolio when tab is clicked
+document.querySelector('.nav-item[data-tab="portfolio"]')?.addEventListener("click", () => {
+    loadPortfolio();
+});
+
+// ── App Init ──────────────────────────────────
+document.addEventListener("DOMContentLoaded", () => {
+    // Load market dashboard when app starts (after welcome dismiss)
+    const letsBeginBtn = document.getElementById("letsBeginBtn");
+    if (letsBeginBtn) {
+        const origHandler = letsBeginBtn.onclick;
+        letsBeginBtn.addEventListener("click", () => {
+            setTimeout(() => startDashboardRefresh(), 500);
+        });
+    }
+    // Also load portfolio after a delay
+    setTimeout(() => loadPortfolio(), 1500);
+});
+
diff --git a/static/style.css b/static/style.css
new file mode 100644
index 0000000..4e50ed2
--- /dev/null
+++ b/static/style.css
@@ -0,0 +1,2212 @@
+/* ══════════════════════════════════════════════════════════
+   FinanceIQ v5 — Professional Design System
+   Light/Dark Mode · Sidebar Layout · Glassmorphism Cards
+   ══════════════════════════════════════════════════════════ */
+
+/* ── FONTS ─────────────────────────────────────────────── */
+:root {
+    --font: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    --radius: 12px;
+    --radius-sm: 8px;
+    --radius-xs: 6px;
+    --sidebar-width: 240px;
+    --topbar-height: 60px;
+    --transition: 0.25s cubic-bezier(0.4, 0, 0.2, 1);
+}
+
+/* ── DARK THEME (default) ──────────────────────────────── */
+[data-theme="dark"] {
+    --bg-root: #0a0e17;
+    --bg-sidebar: #0f1420;
+    --bg-card: #141a2a;
+    --bg-card-hover: #1a2236;
+    --bg-input: #1a2236;
+    --bg-topbar: rgba(10, 14, 23, 0.85);
+    --bg-overlay: rgba(0, 0, 0, 0.6);
+    --border: #1e2a3e;
+    --border-light: #253047;
+    --text-primary: #e8ecf4;
+    --text-secondary: #8b95a8;
+    --text-muted: #5a6577;
+    --accent: #4f8cff;
+    --accent-hover: #6ba0ff;
+    --accent-glow: rgba(79, 140, 255, 0.15);
+    --success: #34d399;
+    --success-bg: rgba(52, 211, 153, 0.1);
+    --danger: #f87171;
+    --danger-bg: rgba(248, 113, 113, 0.1);
+    --warning: #fbbf24;
+    --warning-bg: rgba(251, 191, 36, 0.1);
+    --neutral-bg: rgba(139, 149, 168, 0.1);
+    --shadow: 0 4px 24px rgba(0, 0, 0, 0.3);
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.2);
+    --chart-bg: #141a2a;
+    --chart-text: #8b95a8;
+    --chart-grid: #1e2a3e;
+}
+
+/* ── LIGHT THEME ───────────────────────────────────────── */
+[data-theme="light"] {
+    --bg-root: #f4f6fa;
+    --bg-sidebar: #ffffff;
+    --bg-card: #ffffff;
+    --bg-card-hover: #f8f9fc;
+    --bg-input: #f0f2f6;
+    --bg-topbar: rgba(244, 246, 250, 0.9);
+    --bg-overlay: rgba(255, 255, 255, 0.6);
+    --border: #e2e6ef;
+    --border-light: #eaeef5;
+    --text-primary: #1a1f2e;
+    --text-secondary: #5a6577;
+    --text-muted: #8b95a8;
+    --accent: #3b72e9;
+    --accent-hover: #2b5fd4;
+    --accent-glow: rgba(59, 114, 233, 0.1);
+    --success: #16a34a;
+    --success-bg: rgba(22, 163, 74, 0.08);
+    --danger: #dc2626;
+    --danger-bg: rgba(220, 38, 38, 0.08);
+    --warning: #d97706;
+    --warning-bg: rgba(217, 119, 6, 0.08);
+    --neutral-bg: rgba(90, 101, 119, 0.06);
+    --shadow: 0 4px 24px rgba(0, 0, 0, 0.06);
+    --shadow-sm: 0 2px 8px rgba(0, 0, 0, 0.04);
+    --chart-bg: #ffffff;
+    --chart-text: #5a6577;
+    --chart-grid: #e2e6ef;
+}
+
+/* ── RESET ─────────────────────────────────────────────── */
+*,
+*::before,
+*::after {
+    box-sizing: border-box;
+    margin: 0;
+    padding: 0;
+}
+
+body {
+    font-family: var(--font);
+    background: var(--bg-root);
+    color: var(--text-primary);
+    line-height: 1.6;
+    -webkit-font-smoothing: antialiased;
+    overflow-x: hidden;
+}
+
+/* ══════════════════════════════════════════════════════════
+   WELCOME PAGE
+   ══════════════════════════════════════════════════════════ */
+.welcome-page {
+    position: fixed;
+    inset: 0;
+    z-index: 9999;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: linear-gradient(135deg, #0a0e17 0%, #0d1525 40%, #111d35 100%);
+    overflow: hidden;
+}
+
+.welcome-bg {
+    position: absolute;
+    inset: 0;
+    background:
+        radial-gradient(ellipse at 20% 50%, rgba(79, 140, 255, 0.08) 0%, transparent 50%),
+        radial-gradient(ellipse at 80% 20%, rgba(139, 92, 246, 0.06) 0%, transparent 40%),
+        radial-gradient(ellipse at 50% 80%, rgba(52, 211, 153, 0.04) 0%, transparent 40%);
+}
+
+.welcome-content {
+    position: relative;
+    text-align: center;
+    max-width: 900px;
+    padding: 40px 24px;
+    animation: welcomeFadeIn 0.8s ease-out;
+}
+
+@keyframes welcomeFadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(20px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.welcome-logo {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    gap: 16px;
+    margin-bottom: 16px;
+}
+
+.welcome-icon-wrap {
+    width: 56px;
+    height: 56px;
+    border-radius: 16px;
+    background: linear-gradient(135deg, var(--accent), #8b5cf6);
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    box-shadow: 0 8px 32px rgba(79, 140, 255, 0.3);
+}
+
+.welcome-lucide-icon {
+    width: 32px;
+    height: 32px;
+    color: white;
+}
+
+.welcome-title {
+    font-size: 48px;
+    font-weight: 700;
+    color: white;
+    letter-spacing: -1px;
+}
+
+.badge-version {
+    display: inline-flex;
+    align-items: center;
+    padding: 2px 10px;
+    background: var(--accent-glow);
+    border: 1px solid var(--accent);
+    color: var(--accent);
+    border-radius: 20px;
+    font-size: 12px;
+    font-weight: 600;
+}
+
+.badge-sm {
+    font-size: 10px;
+    padding: 1px 8px;
+}
+
+.welcome-subtitle {
+    font-size: 20px;
+    color: rgba(255, 255, 255, 0.7);
+    font-weight: 400;
+    margin-bottom: 12px;
+}
+
+.welcome-desc {
+    font-size: 14px;
+    color: rgba(255, 255, 255, 0.45);
+    line-height: 1.8;
+    margin-bottom: 40px;
+}
+
+.welcome-features {
+    display: grid;
+    grid-template-columns: repeat(3, 1fr);
+    gap: 16px;
+    margin-bottom: 40px;
+}
+
+.wf-card {
+    background: rgba(255, 255, 255, 0.04);
+    border: 1px solid rgba(255, 255, 255, 0.08);
+    border-radius: var(--radius);
+    padding: 24px 16px;
+    text-align: center;
+    transition: var(--transition);
+}
+
+.wf-card:hover {
+    background: rgba(255, 255, 255, 0.07);
+    border-color: rgba(79, 140, 255, 0.3);
+    transform: translateY(-2px);
+}
+
+.wf-lucide {
+    width: 32px;
+    height: 32px;
+    color: var(--accent);
+    margin-bottom: 12px;
+}
+
+.wf-card h3 {
+    font-size: 15px;
+    font-weight: 600;
+    color: white;
+    margin-bottom: 8px;
+}
+
+.wf-card p {
+    font-size: 12px;
+    color: rgba(255, 255, 255, 0.5);
+    line-height: 1.5;
+}
+
+.welcome-cta {
+    display: inline-flex;
+    align-items: center;
+    gap: 10px;
+    padding: 14px 36px;
+    background: linear-gradient(135deg, var(--accent), #6366f1);
+    color: white;
+    border: none;
+    border-radius: 50px;
+    font-size: 16px;
+    font-weight: 600;
+    cursor: pointer;
+    transition: var(--transition);
+    box-shadow: 0 8px 32px rgba(79, 140, 255, 0.3);
+}
+
+.welcome-cta:hover {
+    transform: translateY(-2px);
+    box-shadow: 0 12px 40px rgba(79, 140, 255, 0.4);
+}
+
+.welcome-footer {
+    margin-top: 32px;
+    font-size: 12px;
+    color: rgba(255, 255, 255, 0.25);
+}
+
+/* ══════════════════════════════════════════════════════════
+   APP LAYOUT (Sidebar + Main)
+   ══════════════════════════════════════════════════════════ */
+.app-layout {
+    display: flex;
+    min-height: 100vh;
+}
+
+/* ── SIDEBAR ───────────────────────────────────────────── */
+.sidebar {
+    width: var(--sidebar-width);
+    background: var(--bg-sidebar);
+    border-right: 1px solid var(--border);
+    display: flex;
+    flex-direction: column;
+    position: fixed;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    z-index: 100;
+    transition: var(--transition);
+}
+
+.sidebar.collapsed {
+    transform: translateX(-100%);
+}
+
+.sidebar-brand {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    padding: 20px 20px 24px;
+    border-bottom: 1px solid var(--border);
+}
+
+.brand-icon {
+    width: 28px;
+    height: 28px;
+    color: var(--accent);
+}
+
+.brand-text {
+    font-size: 18px;
+    font-weight: 700;
+    color: var(--text-primary);
+    letter-spacing: -0.5px;
+}
+
+.sidebar-nav {
+    flex: 1;
+    padding: 12px 8px;
+    overflow-y: auto;
+}
+
+.nav-group-label {
+    padding: 16px 12px 6px;
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 1px;
+    color: var(--text-muted);
+}
+
+.nav-item {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    width: 100%;
+    padding: 10px 12px;
+    background: none;
+    border: none;
+    border-radius: var(--radius-sm);
+    color: var(--text-secondary);
+    font-size: 14px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: var(--transition);
+    text-align: left;
+}
+
+.nav-item i {
+    width: 20px;
+    height: 20px;
+    flex-shrink: 0;
+}
+
+.nav-item:hover {
+    background: var(--accent-glow);
+    color: var(--text-primary);
+}
+
+.nav-item.active {
+    background: var(--accent-glow);
+    color: var(--accent);
+}
+
+.nav-item.active i {
+    color: var(--accent);
+}
+
+.sidebar-bottom {
+    padding: 8px;
+    border-top: 1px solid var(--border);
+}
+
+/* ── MAIN CONTENT ──────────────────────────────────────── */
+.main-content {
+    flex: 1;
+    margin-left: var(--sidebar-width);
+    min-height: 100vh;
+    transition: var(--transition);
+}
+
+.sidebar.collapsed~.main-content {
+    margin-left: 0;
+}
+
+/* ── TOP BAR ───────────────────────────────────────────── */
+.topbar {
+    position: sticky;
+    top: 0;
+    z-index: 50;
+    background: var(--bg-topbar);
+    backdrop-filter: blur(16px);
+    border-bottom: 1px solid var(--border);
+    padding: 12px 24px;
+}
+
+.sidebar-toggle {
+    display: none;
+    background: none;
+    border: none;
+    color: var(--text-secondary);
+    cursor: pointer;
+    padding: 6px;
+    border-radius: var(--radius-xs);
+}
+
+.sidebar-toggle:hover {
+    background: var(--accent-glow);
+}
+
+.search-container {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+/* Asset Selector */
+.asset-selector {
+    display: flex;
+    gap: 4px;
+    background: var(--bg-input);
+    border-radius: var(--radius-sm);
+    padding: 3px;
+}
+
+.asset-btn {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 7px 14px;
+    background: none;
+    border: none;
+    border-radius: var(--radius-xs);
+    color: var(--text-muted);
+    font-size: 13px;
+    font-weight: 500;
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.asset-btn i {
+    width: 15px;
+    height: 15px;
+}
+
+.asset-btn:hover {
+    color: var(--text-primary);
+}
+
+.asset-btn.active {
+    background: var(--bg-card);
+    color: var(--accent);
+    box-shadow: var(--shadow-sm);
+}
+
+[data-theme="light"] .asset-btn.active {
+    box-shadow: 0 1px 4px rgba(0, 0, 0, 0.1);
+}
+
+/* Search Input Group */
+.search-input-group {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    flex-wrap: wrap;
+}
+
+.search-icon {
+    width: 18px;
+    height: 18px;
+    color: var(--text-muted);
+    flex-shrink: 0;
+}
+
+.ticker-wrapper {
+    position: relative;
+    flex: 1;
+    min-width: 200px;
+}
+
+#tickerInput {
+    width: 100%;
+    padding: 9px 14px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    color: var(--text-primary);
+    font-size: 14px;
+    font-family: var(--font);
+    outline: none;
+    transition: var(--transition);
+}
+
+#tickerInput:focus {
+    border-color: var(--accent);
+    box-shadow: 0 0 0 3px var(--accent-glow);
+}
+
+#tickerInput::placeholder {
+    color: var(--text-muted);
+}
+
+.select-control {
+    padding: 9px 12px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    color: var(--text-primary);
+    font-size: 13px;
+    font-family: var(--font);
+    outline: none;
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.select-control:focus {
+    border-color: var(--accent);
+}
+
+.btn-primary {
+    display: inline-flex;
+    align-items: center;
+    gap: 6px;
+    padding: 9px 20px;
+    background: var(--accent);
+    color: white;
+    border: none;
+    border-radius: var(--radius-sm);
+    font-size: 14px;
+    font-weight: 600;
+    font-family: var(--font);
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.btn-primary:hover {
+    background: var(--accent-hover);
+}
+
+.btn-sm {
+    padding: 6px 12px;
+    font-size: 12px;
+}
+
+.custom-dates {
+    display: flex;
+    gap: 12px;
+    padding-left: 26px;
+}
+
+.custom-dates label {
+    font-size: 13px;
+    color: var(--text-secondary);
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.custom-dates input[type="date"] {
+    padding: 6px 10px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-xs);
+    color: var(--text-primary);
+    font-family: var(--font);
+    font-size: 13px;
+}
+
+/* Dropdown */
+.dropdown {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    right: 0;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    max-height: 260px;
+    overflow-y: auto;
+    display: none;
+    z-index: 1000;
+    box-shadow: var(--shadow);
+}
+
+.dropdown.show {
+    display: block;
+}
+
+.dropdown-item {
+    padding: 10px 14px;
+    cursor: pointer;
+    font-size: 13px;
+    color: var(--text-secondary);
+    transition: var(--transition);
+    border-bottom: 1px solid var(--border);
+}
+
+.dropdown-item:last-child {
+    border-bottom: none;
+}
+
+.dropdown-item:hover {
+    background: var(--accent-glow);
+    color: var(--text-primary);
+}
+
+.dropdown-item strong {
+    color: var(--text-primary);
+}
+
+/* ══════════════════════════════════════════════════════════
+   LOADER
+   ══════════════════════════════════════════════════════════ */
+.loader-overlay {
+    position: fixed;
+    inset: 0;
+    background: var(--bg-overlay);
+    backdrop-filter: blur(8px);
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    z-index: 9000;
+}
+
+.loader-spinner {
+    width: 48px;
+    height: 48px;
+    border: 3px solid var(--border);
+    border-top-color: var(--accent);
+    border-radius: 50%;
+    animation: spin 0.8s linear infinite;
+}
+
+@keyframes spin {
+    to {
+        transform: rotate(360deg);
+    }
+}
+
+.loader-text {
+    margin-top: 16px;
+    font-size: 14px;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+/* ══════════════════════════════════════════════════════════
+   TAB PAGES
+   ══════════════════════════════════════════════════════════ */
+.tab-page {
+    display: none;
+    padding: 24px;
+}
+
+.tab-page.active {
+    display: block;
+}
+
+.results {
+    display: grid;
+    grid-template-columns: repeat(2, 1fr);
+    gap: 20px;
+}
+
+/* ══════════════════════════════════════════════════════════
+   CARDS
+   ══════════════════════════════════════════════════════════ */
+.card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 20px;
+    transition: var(--transition);
+}
+
+.card:hover {
+    border-color: var(--border-light);
+    box-shadow: var(--shadow-sm);
+}
+
+.card-full {
+    grid-column: 1 / -1;
+}
+
+.card-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 16px;
+    padding-bottom: 12px;
+    border-bottom: 1px solid var(--border);
+}
+
+.card-title {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 15px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.card-title i {
+    width: 18px;
+    height: 18px;
+    color: var(--accent);
+    flex-shrink: 0;
+}
+
+.info-icon {
+    display: flex;
+    align-items: center;
+    cursor: help;
+    position: relative;
+    color: var(--text-muted);
+}
+
+.info-icon:hover::after {
+    content: attr(data-tooltip);
+    position: absolute;
+    right: 0;
+    top: 100%;
+    margin-top: 8px;
+    padding: 10px 14px;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    font-size: 12px;
+    color: var(--text-secondary);
+    white-space: normal;
+    width: 280px;
+    z-index: 100;
+    box-shadow: var(--shadow);
+    line-height: 1.5;
+    font-weight: 400;
+}
+
+/* AI Card */
+.card-ai {
+    border-color: rgba(79, 140, 255, 0.2);
+    background: linear-gradient(135deg, var(--bg-card), rgba(79, 140, 255, 0.03));
+}
+
+.badge-ai {
+    padding: 2px 8px;
+    background: var(--accent-glow);
+    border: 1px solid rgba(79, 140, 255, 0.3);
+    color: var(--accent);
+    border-radius: 12px;
+    font-size: 11px;
+    font-weight: 600;
+}
+
+.ai-content {
+    min-height: 80px;
+    font-size: 14px;
+    line-height: 1.7;
+    color: var(--text-secondary);
+}
+
+.ai-content p {
+    margin-bottom: 8px;
+}
+
+.ai-placeholder {
+    color: var(--text-muted);
+    font-style: italic;
+}
+
+.ai-actions {
+    display: flex;
+    gap: 8px;
+    margin-top: 16px;
+    padding-top: 12px;
+    border-top: 1px solid var(--border);
+}
+
+.ai-input {
+    flex: 1;
+    padding: 8px 14px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+    color: var(--text-primary);
+    font-size: 13px;
+    font-family: var(--font);
+    outline: none;
+}
+
+.ai-input:focus {
+    border-color: var(--accent);
+}
+
+/* ══════════════════════════════════════════════════════════
+   DATA GRID
+   ══════════════════════════════════════════════════════════ */
+.data-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+    gap: 12px;
+}
+
+.data-item {
+    padding: 12px;
+    background: var(--bg-input);
+    border-radius: var(--radius-sm);
+    border: 1px solid var(--border);
+}
+
+.data-label {
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    color: var(--text-muted);
+    margin-bottom: 4px;
+}
+
+.data-value {
+    font-size: 18px;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+/* ══════════════════════════════════════════════════════════
+   CHART CONTROLS & TOGGLES
+   ══════════════════════════════════════════════════════════ */
+.chart-controls {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-bottom: 12px;
+    align-items: center;
+}
+
+.chart-toggle {
+    display: flex;
+    align-items: center;
+    gap: 5px;
+    padding: 5px 10px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-xs);
+    font-size: 12px;
+    color: var(--text-secondary);
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.chart-toggle:hover {
+    border-color: var(--accent);
+}
+
+.chart-toggle input[type="checkbox"] {
+    accent-color: var(--accent);
+    width: 14px;
+    height: 14px;
+}
+
+.custom-ema {
+    display: flex;
+    gap: 4px;
+    align-items: center;
+    margin-left: auto;
+}
+
+.custom-ema input {
+    width: 90px;
+    padding: 5px 8px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-xs);
+    color: var(--text-primary);
+    font-size: 12px;
+    font-family: var(--font);
+}
+
+/* Monte Carlo band controls */
+.mc-band-controls {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 8px;
+    margin-bottom: 12px;
+}
+
+.mc-stats {
+    display: flex;
+    flex-wrap: wrap;
+    gap: 12px;
+    margin-top: 12px;
+}
+
+/* ══════════════════════════════════════════════════════════
+   PATTERN & OUTLOOK
+   ══════════════════════════════════════════════════════════ */
+.pattern-outlook-box {
+    padding: 12px 16px;
+    border-radius: var(--radius-sm);
+    margin-bottom: 12px;
+    font-size: 14px;
+    font-weight: 600;
+}
+
+.pattern-outlook-box.bullish {
+    background: var(--success-bg);
+    border: 1px solid var(--success);
+    color: var(--success);
+}
+
+.pattern-outlook-box.bearish {
+    background: var(--danger-bg);
+    border: 1px solid var(--danger);
+    color: var(--danger);
+}
+
+.pattern-outlook-box.neutral {
+    background: var(--warning-bg);
+    border: 1px solid var(--warning);
+    color: var(--warning);
+}
+
+.patterns-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(280px, 1fr));
+    gap: 12px;
+}
+
+.pattern-card {
+    padding: 12px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-sm);
+}
+
+.pattern-card .pattern-name {
+    font-weight: 600;
+    font-size: 14px;
+    color: var(--text-primary);
+    margin-bottom: 4px;
+}
+
+.pattern-card .pattern-date {
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.pattern-card .pattern-prediction {
+    margin-top: 6px;
+    font-size: 13px;
+    color: var(--text-secondary);
+    font-style: italic;
+}
+
+/* ══════════════════════════════════════════════════════════
+   TABLES
+   ══════════════════════════════════════════════════════════ */
+.table-container {
+    overflow-x: auto;
+}
+
+table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 13px;
+}
+
+table th {
+    padding: 10px 14px;
+    text-align: left;
+    font-size: 11px;
+    font-weight: 600;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    color: var(--text-muted);
+    border-bottom: 2px solid var(--border);
+    background: var(--bg-input);
+}
+
+table td {
+    padding: 10px 14px;
+    border-bottom: 1px solid var(--border);
+    color: var(--text-secondary);
+}
+
+table tr:hover td {
+    background: var(--accent-glow);
+}
+
+/* ══════════════════════════════════════════════════════════
+   HEATMAP & CORRELATION
+   ══════════════════════════════════════════════════════════ */
+.heatmap-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+    gap: 8px;
+}
+
+.heatmap-cell {
+    padding: 14px 12px;
+    border-radius: var(--radius-sm);
+    text-align: center;
+    font-size: 13px;
+    font-weight: 600;
+    transition: var(--transition);
+}
+
+.heatmap-controls {
+    display: flex;
+    gap: 6px;
+    margin-bottom: 12px;
+    flex-wrap: wrap;
+}
+
+.heatmap-controls button {
+    padding: 6px 12px;
+    background: var(--bg-input);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-xs);
+    color: var(--text-secondary);
+    font-size: 12px;
+    cursor: pointer;
+    transition: var(--transition);
+}
+
+.heatmap-controls button.active,
+.heatmap-controls button:hover {
+    background: var(--accent-glow);
+    border-color: var(--accent);
+    color: var(--accent);
+}
+
+.corr-matrix {
+    overflow-x: auto;
+}
+
+/* ══════════════════════════════════════════════════════════
+   COMPETITOR SECTION
+   ══════════════════════════════════════════════════════════ */
+.comp-container {
+    overflow-x: auto;
+}
+
+/* ══════════════════════════════════════════════════════════
+   MACRO INDICATOR BADGES
+   ══════════════════════════════════════════════════════════ */
+.macro-badge {
+    display: inline-flex;
+    align-items: center;
+    gap: 4px;
+    padding: 2px 8px;
+    border-radius: 10px;
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+}
+
+.macro-badge.good {
+    background: var(--success-bg);
+    color: var(--success);
+}
+
+.macro-badge.bad {
+    background: var(--danger-bg);
+    color: var(--danger);
+}
+
+.macro-badge.neutral {
+    background: var(--neutral-bg);
+    color: var(--text-muted);
+}
+
+/* ══════════════════════════════════════════════════════════
+   SIGNAL BOX
+   ══════════════════════════════════════════════════════════ */
+.signal-box {
+    padding: 16px;
+    border-radius: var(--radius-sm);
+    font-size: 18px;
+    font-weight: 700;
+    text-align: center;
+}
+
+.signal-box.buy {
+    background: var(--success-bg);
+    color: var(--success);
+    border: 1px solid var(--success);
+}
+
+.signal-box.sell {
+    background: var(--danger-bg);
+    color: var(--danger);
+    border: 1px solid var(--danger);
+}
+
+.signal-box.hold {
+    background: var(--warning-bg);
+    color: var(--warning);
+    border: 1px solid var(--warning);
+}
+
+/* ══════════════════════════════════════════════════════════
+   FOOTER
+   ══════════════════════════════════════════════════════════ */
+.footer {
+    padding: 20px 24px;
+    text-align: center;
+    font-size: 12px;
+    color: var(--text-muted);
+    border-top: 1px solid var(--border);
+    margin-top: 40px;
+}
+
+/* ══════════════════════════════════════════════════════════
+   RESPONSIVE
+   ══════════════════════════════════════════════════════════ */
+@media (max-width: 1024px) {
+    .sidebar {
+        transform: translateX(-100%);
+    }
+
+    .sidebar.open {
+        transform: translateX(0);
+    }
+
+    .main-content {
+        margin-left: 0;
+    }
+
+    .sidebar-toggle {
+        display: block;
+    }
+
+    .results {
+        grid-template-columns: 1fr;
+    }
+
+    .welcome-features {
+        grid-template-columns: repeat(2, 1fr);
+    }
+}
+
+@media (max-width: 640px) {
+    .welcome-features {
+        grid-template-columns: 1fr;
+    }
+
+    .welcome-title {
+        font-size: 32px;
+    }
+
+    .search-input-group {
+        flex-direction: column;
+    }
+
+    .asset-selector {
+        flex-wrap: wrap;
+    }
+
+    .topbar {
+        padding: 12px 16px;
+    }
+
+    .tab-page {
+        padding: 16px;
+    }
+}
+
+/* ══════════════════════════════════════════════════════════
+   SCROLLBAR
+   ══════════════════════════════════════════════════════════ */
+::-webkit-scrollbar {
+    width: 6px;
+    height: 6px;
+}
+
+::-webkit-scrollbar-track {
+    background: transparent;
+}
+
+::-webkit-scrollbar-thumb {
+    background: var(--border);
+    border-radius: 3px;
+}
+
+::-webkit-scrollbar-thumb:hover {
+    background: var(--text-muted);
+}
+
+/* ══════════════════════════════════════════════════════════
+   UTILITY CLASSES
+   ══════════════════════════════════════════════════════════ */
+.text-success {
+    color: var(--success) !important;
+}
+
+.text-danger {
+    color: var(--danger) !important;
+}
+
+.text-warning {
+    color: var(--warning) !important;
+}
+
+.text-muted {
+    color: var(--text-muted) !important;
+}
+
+.text-accent {
+    color: var(--accent) !important;
+}
+
+/* ── Price Flash Animation ─────────────────────────────── */
+@keyframes priceFlash {
+    0% {
+        background: var(--accent-glow);
+    }
+
+    100% {
+        background: transparent;
+    }
+}
+
+.price-flash {
+    animation: priceFlash 0.6s ease-out;
+}
+
+/* ── DCF Valuation ─────────────────────────────────────── */
+.dcf-hero {
+    text-align: center;
+}
+
+.dcf-verdict {
+    font-size: 24px;
+    font-weight: 700;
+    margin-bottom: 16px;
+}
+
+.dcf-verdict.undervalued {
+    color: var(--success);
+}
+
+.dcf-verdict.overvalued {
+    color: var(--danger);
+}
+
+.dcf-verdict.fair {
+    color: var(--warning);
+}
+
+.dcf-sub {
+    font-size: 14px;
+    font-weight: 500;
+    margin-top: 4px;
+    opacity: 0.8;
+}
+
+.dcf-metrics {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(160px, 1fr));
+    gap: 12px;
+    margin-top: 16px;
+}
+
+/* ── Z-Score ───────────────────────────────────────────── */
+.zscore-badge {
+    text-align: center;
+    font-size: 36px;
+    font-weight: 700;
+    padding: 16px;
+    border-radius: var(--radius);
+    margin-bottom: 12px;
+}
+
+.zscore-badge.safe {
+    background: var(--success-bg);
+    color: var(--success);
+}
+
+.zscore-badge.grey {
+    background: var(--warning-bg);
+    color: var(--warning);
+}
+
+.zscore-badge.distress {
+    background: var(--danger-bg);
+    color: var(--danger);
+}
+
+.zscore-components {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+    gap: 8px;
+}
+
+/* ── Fear & Greed ──────────────────────────────────────── */
+.fg-gauge {
+    text-align: center;
+    padding: 16px 0;
+}
+
+.fg-value {
+    font-size: 48px;
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.fg-label {
+    font-size: 16px;
+    font-weight: 600;
+    margin: 8px 0 16px;
+}
+
+.fg-bar {
+    height: 8px;
+    background: linear-gradient(to right, var(--danger), var(--warning), var(--success));
+    border-radius: 4px;
+    position: relative;
+    margin: 0 20px;
+}
+
+.fg-marker {
+    position: absolute;
+    top: -6px;
+    width: 20px;
+    height: 20px;
+    background: var(--text-primary);
+    border-radius: 50%;
+    border: 3px solid var(--bg-card);
+    transform: translateX(-50%);
+}
+
+/* ── VIX ───────────────────────────────────────────────── */
+.vix-display {
+    text-align: center;
+    padding: 16px 0;
+}
+
+.vix-value {
+    font-size: 48px;
+    font-weight: 700;
+}
+
+/* ── News ──────────────────────────────────────────────── */
+.news-item {
+    padding: 12px 0;
+    border-bottom: 1px solid var(--border);
+}
+
+.news-item:last-child {
+    border-bottom: none;
+}
+
+.news-title a {
+    color: var(--text-primary);
+    text-decoration: none;
+    font-weight: 500;
+}
+
+.news-title a:hover {
+    color: var(--accent);
+}
+
+.news-meta {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+    margin-top: 6px;
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.sentiment-badge {
+    margin-bottom: 16px;
+}
+
+.sentiment-pill {
+    padding: 3px 10px;
+    border-radius: 12px;
+    font-size: 12px;
+    font-weight: 600;
+}
+
+.sentiment-pill.positive {
+    background: var(--success-bg);
+    color: var(--success);
+}
+
+.sentiment-pill.negative {
+    background: var(--danger-bg);
+    color: var(--danger);
+}
+
+.sentiment-pill.neutral {
+    background: var(--neutral-bg);
+    color: var(--text-muted);
+}
+
+/* ── Analyst ───────────────────────────────────────────── */
+.analyst-bars {
+    margin-bottom: 16px;
+}
+
+.analyst-bar-row {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    margin-bottom: 6px;
+}
+
+.analyst-bar-label {
+    width: 80px;
+    font-size: 12px;
+    color: var(--text-muted);
+    text-align: right;
+}
+
+.analyst-bar-track {
+    flex: 1;
+    height: 24px;
+    background: var(--bg-input);
+    border-radius: var(--radius-xs);
+    overflow: hidden;
+}
+
+.analyst-bar-fill {
+    height: 100%;
+    display: flex;
+    align-items: center;
+    padding: 0 8px;
+    font-size: 11px;
+    font-weight: 600;
+    color: white;
+    border-radius: var(--radius-xs);
+}
+
+.analyst-bar-fill.buy {
+    background: var(--success);
+}
+
+.analyst-bar-fill.hold {
+    background: var(--warning);
+}
+
+.analyst-bar-fill.sell {
+    background: var(--danger);
+}
+
+.analyst-na {
+    padding: 16px;
+    text-align: center;
+    color: var(--text-muted);
+}
+
+.price-target-grid {
+    display: grid;
+    grid-template-columns: repeat(4, 1fr);
+    gap: 8px;
+}
+
+/* ── Pattern Cards ─────────────────────────────────────── */
+.pattern-card {
+    display: flex;
+    gap: 12px;
+    padding: 12px;
+    border-radius: var(--radius);
+    background: var(--bg-hover);
+    margin-bottom: 8px;
+}
+
+.pattern-badge {
+    padding: 4px 10px;
+    border-radius: 8px;
+    font-size: 11px;
+    font-weight: 700;
+    text-transform: uppercase;
+    white-space: nowrap;
+}
+
+.pattern-badge.bullish {
+    background: var(--success-bg);
+    color: var(--success);
+}
+
+.pattern-badge.bearish {
+    background: var(--danger-bg);
+    color: var(--danger);
+}
+
+.pattern-badge.neutral {
+    background: var(--neutral-bg);
+    color: var(--text-muted);
+}
+
+.pattern-info h4 {
+    margin: 0 0 4px;
+    font-size: 14px;
+}
+
+.pattern-info .date {
+    font-size: 12px;
+    color: var(--text-muted);
+}
+
+.pattern-info p {
+    font-size: 13px;
+    color: var(--text-secondary);
+    margin: 4px 0;
+}
+
+.pattern-prediction {
+    font-size: 12px;
+    color: var(--accent);
+    font-weight: 500;
+}
+
+.pattern-outlook-box {
+    padding: 12px 16px;
+    border-radius: var(--radius);
+    margin-bottom: 16px;
+    font-weight: 600;
+}
+
+.pattern-outlook-box.bullish {
+    background: var(--success-bg);
+    color: var(--success);
+}
+
+.pattern-outlook-box.bearish {
+    background: var(--danger-bg);
+    color: var(--danger);
+}
+
+.pattern-outlook-box.neutral {
+    background: var(--neutral-bg);
+    color: var(--text-muted);
+}
+
+.pattern-outlook-sub {
+    font-size: 12px;
+    font-weight: 400;
+    margin-top: 4px;
+    opacity: 0.8;
+}
+
+/* ── Heatmap ───────────────────────────────────────────── */
+.heatmap-btn {
+    padding: 4px 12px;
+    border: 1px solid var(--border);
+    background: transparent;
+    color: var(--text-secondary);
+    border-radius: var(--radius-xs);
+    cursor: pointer;
+    font-size: 12px;
+}
+
+.heatmap-btn.active {
+    background: var(--accent);
+    color: white;
+    border-color: var(--accent);
+}
+
+/* ── Signal Box ────────────────────────────────────────── */
+.signal-box {
+    padding: 16px;
+    border-radius: var(--radius);
+    text-align: center;
+}
+
+.signal-box.bullish {
+    background: var(--success-bg);
+}
+
+.signal-box.bearish {
+    background: var(--danger-bg);
+}
+
+.signal-box.neutral {
+    background: var(--neutral-bg);
+}
+
+.signal-verdict {
+    font-size: 28px;
+    font-weight: 800;
+}
+
+.signal-verdict.bullish {
+    color: var(--success);
+}
+
+.signal-verdict.bearish {
+    color: var(--danger);
+}
+
+.signal-verdict.neutral {
+    color: var(--warning);
+}
+
+.signal-reason {
+    font-size: 12px;
+    color: var(--text-muted);
+    margin-top: 4px;
+}
+
+/* ── Misc ──────────────────────────────────────────────── */
+.comp-target {
+    background: var(--accent-glow) !important;
+}
+
+.badge-sector {
+    padding: 2px 8px;
+    background: var(--accent-glow);
+    color: var(--accent);
+    border-radius: 10px;
+    font-size: 11px;
+    font-weight: 600;
+}
+
+.dividend-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(140px, 1fr));
+    gap: 12px;
+}
+
+.macro-status-badge {
+    display: inline-block;
+    padding: 1px 6px;
+    border-radius: 8px;
+    font-size: 10px;
+    font-weight: 700;
+    text-transform: uppercase;
+}
+
+.macro-status-badge.good {
+    background: var(--success-bg);
+    color: var(--success);
+}
+
+.macro-status-badge.bad {
+    background: var(--danger-bg);
+    color: var(--danger);
+}
+
+.macro-explanation {
+    font-size: 11px;
+    color: var(--text-muted);
+    margin-top: 4px;
+}
+
+.surprise-positive {
+    color: var(--success) !important;
+    font-weight: 600;
+}
+
+.surprise-negative {
+    color: var(--danger) !important;
+    font-weight: 600;
+}
+
+.ai-placeholder {
+    color: var(--text-muted);
+    font-style: italic;
+}
+
+/* ── Options Chain ─────────────────────────── */
+.options-controls {
+    display: flex;
+    gap: 8px;
+    align-items: center;
+}
+
+.options-toggle {
+    display: flex;
+    gap: 4px;
+    padding: 8px 16px 0;
+}
+
+.table-container {
+    overflow-x: auto;
+    padding: 0 16px 16px;
+}
+
+.data-table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 0.82rem;
+}
+
+.data-table thead th {
+    text-align: left;
+    padding: 8px 10px;
+    font-weight: 600;
+    color: var(--text-muted);
+    border-bottom: 1px solid var(--border);
+    font-size: 0.75rem;
+    text-transform: uppercase;
+    letter-spacing: 0.5px;
+    white-space: nowrap;
+}
+
+.data-table tbody td {
+    padding: 6px 10px;
+    border-bottom: 1px solid var(--border);
+    color: var(--text-primary);
+}
+
+.data-table tbody tr:hover {
+    background: var(--bg-card-hover, rgba(255, 255, 255, 0.03));
+}
+
+.data-table .positive {
+    color: var(--success);
+}
+
+.data-table .negative {
+    color: var(--danger);
+}
+
+/* ── Payoff Controls ─────────────────────────── */
+.payoff-controls {
+    display: flex;
+    gap: 12px;
+    align-items: center;
+    padding: 12px 16px;
+    flex-wrap: wrap;
+}
+
+.payoff-controls label {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    font-size: 0.85rem;
+    color: var(--text-secondary);
+}
+
+.input-sm {
+    padding: 6px 10px;
+    border-radius: var(--radius-xs);
+    border: 1px solid var(--border);
+    background: var(--bg-input);
+    color: var(--text-primary);
+    font-size: 0.85rem;
+    width: 90px;
+    outline: none;
+    transition: border-color 0.2s;
+}
+
+.input-sm:focus {
+    border-color: var(--accent);
+}
+
+/* ── Portfolio ─────────────────────────── */
+.portfolio-summary-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+    gap: 16px;
+    padding: 16px;
+}
+
+.portfolio-analytics-grid {
+    padding: 16px;
+}
+
+.portfolio-analytics-grid .data-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(140px, 1fr));
+    gap: 12px;
+}
+
+/* ── Trade Form ─────────────────────────── */
+.trade-form {
+    display: flex;
+    gap: 10px;
+    align-items: center;
+    padding: 16px;
+    flex-wrap: wrap;
+}
+
+.trade-form .input-sm {
+    width: 140px;
+}
+
+.trade-result {
+    padding: 0 16px 16px;
+    font-size: 0.88rem;
+    min-height: 24px;
+}
+
+/* ── Danger Button ─────────────────────────── */
+.btn-danger {
+    background: var(--danger);
+    color: #fff;
+    border: none;
+    padding: 6px 14px;
+    border-radius: var(--radius-xs);
+    cursor: pointer;
+    font-size: 0.82rem;
+    font-weight: 500;
+    display: flex;
+    align-items: center;
+    gap: 4px;
+    transition: opacity 0.2s;
+}
+
+.btn-danger:hover {
+    opacity: 0.85;
+}
+
+/* ══════════════════════════════════════════════════════
+   v5.2 — Market Dashboard
+   ══════════════════════════════════════════════════════ */
+.market-dashboard {
+    padding: 20px 0 8px;
+}
+
+.dashboard-header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 20px;
+    flex-wrap: wrap;
+    gap: 8px;
+}
+
+.dashboard-title {
+    font-size: 1.25rem;
+    font-weight: 700;
+    color: var(--text-primary);
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    margin: 0;
+    background: linear-gradient(135deg, var(--accent), #a78bfa, #f472b6);
+    -webkit-background-clip: text;
+    -webkit-text-fill-color: transparent;
+    background-clip: text;
+}
+
+.dashboard-subtitle {
+    font-size: 0.8rem;
+    color: var(--text-muted);
+}
+
+.dashboard-section {
+    margin-bottom: 20px;
+}
+
+.dash-section-title {
+    font-size: 0.82rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+    text-transform: uppercase;
+    letter-spacing: 0.6px;
+    margin: 0 0 10px 0;
+    display: flex;
+    align-items: center;
+    gap: 6px;
+}
+
+.market-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+    gap: 12px;
+}
+
+/* Glassmorphism market card */
+.market-card {
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius);
+    padding: 16px;
+    position: relative;
+    overflow: hidden;
+    transition: transform 0.3s ease, box-shadow 0.3s ease;
+    animation: cardFadeIn 0.5s ease-out both;
+}
+
+.market-card::before {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background: linear-gradient(135deg, rgba(99, 102, 241, 0.06), rgba(168, 85, 247, 0.04));
+    pointer-events: none;
+}
+
+.market-card:hover {
+    transform: translateY(-3px) scale(1.02);
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.15);
+}
+
+.market-card .mc-name {
+    font-size: 0.78rem;
+    color: var(--text-muted);
+    font-weight: 500;
+    margin-bottom: 4px;
+}
+
+.market-card .mc-price {
+    font-size: 1.2rem;
+    font-weight: 700;
+    color: var(--text-primary);
+}
+
+.market-card .mc-change {
+    font-size: 0.82rem;
+    font-weight: 600;
+    margin-top: 4px;
+}
+
+.market-card .mc-change.positive {
+    color: var(--success);
+}
+
+.market-card .mc-change.negative {
+    color: var(--danger);
+}
+
+/* Live pulse dot */
+.live-dot {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    background: var(--success);
+    border-radius: 50%;
+    animation: livePulse 2s ease-in-out infinite;
+}
+
+@keyframes livePulse {
+
+    0%,
+    100% {
+        opacity: 1;
+        box-shadow: 0 0 0 0 rgba(34, 197, 94, 0.5);
+    }
+
+    50% {
+        opacity: 0.6;
+        box-shadow: 0 0 0 6px rgba(34, 197, 94, 0);
+    }
+}
+
+/* Skeleton loaders */
+.skeleton-card {
+    min-height: 80px;
+    display: flex;
+    flex-direction: column;
+    justify-content: center;
+    gap: 8px;
+}
+
+.skeleton-line {
+    height: 14px;
+    background: linear-gradient(90deg, var(--bg-input) 25%, rgba(255, 255, 255, 0.08) 50%, var(--bg-input) 75%);
+    background-size: 200% 100%;
+    border-radius: 4px;
+    animation: shimmer 1.5s infinite;
+}
+
+.skeleton-line.short {
+    width: 60%;
+}
+
+@keyframes shimmer {
+    0% {
+        background-position: 200% 0;
+    }
+
+    100% {
+        background-position: -200% 0;
+    }
+}
+
+/* Staggered card fade-in */
+@keyframes cardFadeIn {
+    from {
+        opacity: 0;
+        transform: translateY(16px);
+    }
+
+    to {
+        opacity: 1;
+        transform: translateY(0);
+    }
+}
+
+.market-card:nth-child(1) {
+    animation-delay: 0s;
+}
+
+.market-card:nth-child(2) {
+    animation-delay: 0.08s;
+}
+
+.market-card:nth-child(3) {
+    animation-delay: 0.16s;
+}
+
+.market-card:nth-child(4) {
+    animation-delay: 0.24s;
+}
+
+.market-card:nth-child(5) {
+    animation-delay: 0.32s;
+}
+
+.market-card:nth-child(6) {
+    animation-delay: 0.4s;
+}
+
+/* ══════════════════════════════════════════════════════
+   v5.2 — Trade Terminal
+   ══════════════════════════════════════════════════════ */
+.trade-search-wrap {
+    position: relative;
+    flex: 1;
+    min-width: 160px;
+}
+
+.trade-search-wrap .input-sm {
+    width: 100%;
+}
+
+.trade-dropdown {
+    display: none;
+    position: absolute;
+    top: 100%;
+    left: 0;
+    right: 0;
+    background: var(--bg-card);
+    border: 1px solid var(--border);
+    border-radius: var(--radius-xs);
+    max-height: 200px;
+    overflow-y: auto;
+    z-index: 50;
+    box-shadow: 0 8px 24px rgba(0, 0, 0, 0.3);
+}
+
+.trade-dropdown.open {
+    display: block;
+}
+
+.trade-dropdown-item {
+    padding: 8px 12px;
+    cursor: pointer;
+    font-size: 0.85rem;
+    display: flex;
+    justify-content: space-between;
+    color: var(--text-primary);
+    transition: background 0.15s;
+}
+
+.trade-dropdown-item:hover {
+    background: var(--bg-input);
+}
+
+.trade-dropdown-item .ticker-sym {
+    font-weight: 600;
+}
+
+.trade-dropdown-item .ticker-name {
+    color: var(--text-muted);
+    font-size: 0.8rem;
+}
+
+.trade-btn-group {
+    display: flex;
+    gap: 6px;
+    flex-wrap: wrap;
+}
+
+.btn-trade {
+    padding: 8px 16px;
+    border: none;
+    border-radius: var(--radius-xs);
+    cursor: pointer;
+    font-size: 0.82rem;
+    font-weight: 600;
+    transition: all 0.2s;
+    letter-spacing: 0.3px;
+}
+
+.btn-buy {
+    background: linear-gradient(135deg, #22c55e, #16a34a);
+    color: #fff;
+}
+
+.btn-buy:hover {
+    box-shadow: 0 4px 12px rgba(34, 197, 94, 0.4);
+    transform: translateY(-1px);
+}
+
+.btn-sell {
+    background: linear-gradient(135deg, #ef4444, #dc2626);
+    color: #fff;
+}
+
+.btn-sell:hover {
+    box-shadow: 0 4px 12px rgba(239, 68, 68, 0.4);
+    transform: translateY(-1px);
+}
+
+.btn-short {
+    background: linear-gradient(135deg, #f59e0b, #d97706);
+    color: #fff;
+}
+
+.btn-short:hover {
+    box-shadow: 0 4px 12px rgba(245, 158, 11, 0.4);
+    transform: translateY(-1px);
+}
+
+.btn-cover {
+    background: linear-gradient(135deg, #6366f1, #4f46e5);
+    color: #fff;
+}
+
+.btn-cover:hover {
+    box-shadow: 0 4px 12px rgba(99, 102, 241, 0.4);
+    transform: translateY(-1px);
+}
+
+/* ══════════════════════════════════════════════════════
+   v5.2 — Welcome Page Particles
+   ══════════════════════════════════════════════════════ */
+.welcome-bg::after {
+    content: '';
+    position: absolute;
+    inset: 0;
+    background-image:
+        radial-gradient(2px 2px at 10% 20%, rgba(99, 102, 241, 0.4), transparent),
+        radial-gradient(2px 2px at 30% 70%, rgba(168, 85, 247, 0.3), transparent),
+        radial-gradient(3px 3px at 50% 40%, rgba(244, 114, 182, 0.3), transparent),
+        radial-gradient(2px 2px at 70% 80%, rgba(59, 130, 246, 0.3), transparent),
+        radial-gradient(2px 2px at 90% 30%, rgba(34, 197, 94, 0.3), transparent),
+        radial-gradient(3px 3px at 20% 90%, rgba(251, 191, 36, 0.2), transparent),
+        radial-gradient(2px 2px at 80% 10%, rgba(99, 102, 241, 0.3), transparent),
+        radial-gradient(2px 2px at 60% 60%, rgba(168, 85, 247, 0.25), transparent);
+    animation: particleDrift 20s ease-in-out infinite alternate;
+    pointer-events: none;
+}
+
+@keyframes particleDrift {
+    0% {
+        transform: translate(0, 0) scale(1);
+    }
+
+    25% {
+        transform: translate(10px, -15px) scale(1.02);
+    }
+
+    50% {
+        transform: translate(-8px, 10px) scale(0.98);
+    }
+
+    75% {
+        transform: translate(12px, 5px) scale(1.01);
+    }
+
+    100% {
+        transform: translate(-5px, -10px) scale(1);
+    }
+}
+
+/* Staggered welcome feature card animations */
+.wf-card {
+    animation: cardFadeIn 0.6s ease-out both;
+}
+
+.wf-card:nth-child(1) {
+    animation-delay: 0.1s;
+}
+
+.wf-card:nth-child(2) {
+    animation-delay: 0.2s;
+}
+
+.wf-card:nth-child(3) {
+    animation-delay: 0.3s;
+}
+
+.wf-card:nth-child(4) {
+    animation-delay: 0.4s;
+}
+
+.wf-card:nth-child(5) {
+    animation-delay: 0.5s;
+}
+
+.wf-card:nth-child(6) {
+    animation-delay: 0.6s;
+}
+
+/* 3D tilt on hover for welcome cards */
+.wf-card:hover {
+    transform: perspective(600px) rotateX(-3deg) rotateY(3deg) translateY(-4px);
+    box-shadow: 0 12px 32px rgba(0, 0, 0, 0.2);
+}
+
+/* Badge styling enhancements */
+.badge-sm {
+    font-size: 0.68rem;
+    padding: 2px 8px;
+    border-radius: 10px;
+    background: var(--bg-input);
+    color: var(--text-muted);
+    font-weight: 500;
+    border: 1px solid var(--border);
+}
\ No newline at end of file
diff --git a/technical_analyzer.py b/technical_analyzer.py
new file mode 100644
index 0000000..fdb1694
--- /dev/null
+++ b/technical_analyzer.py
@@ -0,0 +1,205 @@
+"""
+Module for Technical Analysis using FinanceToolkit.
+Calculates RSI, EMA, Volatility, MACD, Bollinger Bands, and Fibonacci Retracement Levels.
+"""
+from financetoolkit import Toolkit
+import pandas as pd
+import numpy as np
+
+def get_technicals(ticker, api_key, period="daily"):
+    """
+    Fetches comprehensive technical indicators for a given ticker.
+    
+    Args:
+        ticker (str): Stock ticker symbol.
+        api_key (str): FMP API Key.
+        period (str): 'daily', 'weekly', etc.
+        
+    Returns:
+        dict: Latest technical values and signals for 'Pro' analysis.
+    """
+    try:
+        companies = Toolkit(
+            tickers=[ticker],
+            api_key=api_key,
+        )
+        
+        # Helper to safely get the latest value for the specific ticker
+        def get_latest_series(df, col_name=None):
+            if df.empty: return 0
+            # multi-index handling: typically (Symbol, Metric) or (Metric, Symbol)
+            if isinstance(df.columns, pd.MultiIndex):
+                # Try selecting ticker from level 1
+                if ticker in df.columns.get_level_values(1):
+                    df = df.xs(ticker, level=1, axis=1)
+                # Try selecting ticker from level 0
+                elif ticker in df.columns.get_level_values(0):
+                    df = df.xs(ticker, level=0, axis=1)
+            
+            # If still DataFrame, try to pick the specific column or just the first
+            if isinstance(df, pd.DataFrame):
+                if col_name and col_name in df.columns:
+                    return df[col_name].iloc[-1]
+                return df.iloc[-1, 0] # Default to first column
+            else:
+                return df.iloc[-1]
+
+        def get_value(val):
+            return val.values[0] if hasattr(val, 'values') else val
+
+        # 1. RSI (14 periods) - Good for Overbought/Oversold
+        rsi_df = companies.technicals.get_relative_strength_index(window=14)
+        current_rsi = get_value(get_latest_series(rsi_df))
+        
+        # 2. EMA (50 periods) - Trend Filter
+        ema_df = companies.technicals.get_exponential_moving_average(window=50)
+        current_ema = get_value(get_latest_series(ema_df))
+
+        # 2b. EMA (10 periods) - Short Term Trend (Phase 3)
+        ema10_df = companies.technicals.get_exponential_moving_average(window=10)
+        current_ema10 = get_value(get_latest_series(ema10_df))
+
+        # 2c. EMA (5 periods) - Ultra-Short Term (Phase 5 Aggressive)
+        ema5_df = companies.technicals.get_exponential_moving_average(window=5)
+        current_ema5 = get_value(get_latest_series(ema5_df))
+        
+        # 3. MACD (12, 26, 9) - Momentum
+        macd_df = companies.technicals.get_moving_average_convergence_divergence(short_window=12, long_window=26, signal_window=9)
+        # MACD usually returns MACD line and Signal line. We need both.
+        # Structure likely: [MACD, Signal, Histogram] columns per ticker
+        # Let's get the full series for the ticker first
+        if isinstance(macd_df.columns, pd.MultiIndex):
+             if ticker in macd_df.columns.get_level_values(1):
+                macd_data = macd_df.xs(ticker, level=1, axis=1)
+             elif ticker in macd_df.columns.get_level_values(0):
+                macd_data = macd_df.xs(ticker, level=0, axis=1)
+             else:
+                macd_data = macd_df
+        else:
+            macd_data = macd_df
+
+        # Assuming columns like 'MACD', 'Signal', 'Histogram' or similar exist
+        # If columns are just numbered or named differently, we take last row
+        if 'MACD' in macd_data.columns and 'Signal' in macd_data.columns:
+            current_macd = macd_data['MACD'].iloc[-1]
+            current_signal_line = macd_data['Signal'].iloc[-1]
+        else:
+            # Fallback: assume col 0 is MACD, col 1 is Signal (standard toolkit output order often)
+            current_macd = macd_data.iloc[-1, 0]
+            current_signal_line = macd_data.iloc[-1, 1] if macd_data.shape[1] > 1 else 0
+
+        # 4. Bollinger Bands (20, 2) - Volatility & Mean Reversion
+        bb_df = companies.technicals.get_bollinger_bands(window=20, num_std_dev=2)
+        # Usually returns: Upper, Lower, (maybe Middle)
+        if isinstance(bb_df.columns, pd.MultiIndex):
+             if ticker in bb_df.columns.get_level_values(1):
+                bb_data = bb_df.xs(ticker, level=1, axis=1)
+             elif ticker in bb_df.columns.get_level_values(0):
+                bb_data = bb_df.xs(ticker, level=0, axis=1)
+             else:
+                bb_data = bb_df
+        else:
+            bb_data = bb_df
+            
+        # Inspect columns for Upper/Lower
+        # Typ. 'Bollinger High', 'Bollinger Low' or similar
+        # Fallback to column indices if names vary
+        if bb_data.shape[1] >= 2:
+            bb_upper = bb_data.iloc[-1, 0] # Often Upper is first or checking names
+            bb_lower = bb_data.iloc[-1, 1]
+            # Try to be more specific if possible, but for now robust fallback
+            # Let's look for 'Upper' or 'High' in columns
+            for col in bb_data.columns:
+                if 'Upper' in str(col) or 'High' in str(col): bb_upper = bb_data[col].iloc[-1]
+                if 'Lower' in str(col) or 'Low' in str(col): bb_lower = bb_data[col].iloc[-1]
+        else:
+            bb_upper = 0
+            bb_lower = 0
+
+        # 5. Volatility & Fibonacci & NEW EXPERT METRICS (SMA, Volume, ATR)
+        hist_data = companies.get_historical_data()
+        
+        atr = 0
+        rvol = 0
+        sma_200 = 0
+        sma_50 = 0
+        
+        if not hist_data.empty:
+            # Handle MultiIndex
+            if isinstance(hist_data.columns, pd.MultiIndex):
+                try:
+                    if ticker in hist_data.columns.get_level_values(1):
+                        hist_data = hist_data.xs(ticker, level=1, axis=1)
+                    elif ticker in hist_data.columns.get_level_values(0):
+                        hist_data = hist_data.xs(ticker, level=0, axis=1)
+                except: pass
+                
+            daily_returns = hist_data['Return'].iloc[-20:]
+            volatility = daily_returns.std() * np.sqrt(252) * 100 
+            current_close = hist_data['Close'].iloc[-1]
+            if isinstance(current_close, pd.Series): current_close = current_close.iloc[0]
+            
+            # --- EXPERT METRICS ---
+            # SMA 50 & 200
+            sma_50 = hist_data['Close'].rolling(window=50).mean().iloc[-1]
+            sma_200 = hist_data['Close'].rolling(window=200).mean().iloc[-1]
+            
+            # Volume Relative Strength (RVOL)
+            # Current Volume / Avg Volume 20
+            curr_vol = hist_data['Volume'].iloc[-1]
+            avg_vol_20 = hist_data['Volume'].rolling(window=20).mean().iloc[-1]
+            rvol = curr_vol / avg_vol_20 if avg_vol_20 > 0 else 0
+            
+            # ATR (14)
+            high = hist_data['High']
+            low = hist_data['Low']
+            close = hist_data['Close']
+            tr1 = high - low
+            tr2 = (high - close.shift()).abs()
+            tr3 = (low - close.shift()).abs()
+            tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+            atr = tr.rolling(window=14).mean().iloc[-1]
+            
+            # Fibonacci
+            last_year = hist_data.iloc[-252:]
+            high_price = last_year['High'].max()
+            low_price = last_year['Low'].min()
+            if isinstance(high_price, pd.Series): high_price = high_price.iloc[0]
+            if isinstance(low_price, pd.Series): low_price = low_price.iloc[0]
+            
+            diff = high_price - low_price
+            fib_levels = {
+                '0.0%': high_price,
+                '23.6%': high_price - 0.236 * diff,
+                '38.2%': high_price - 0.382 * diff,
+                '50.0%': high_price - 0.5 * diff,
+                '61.8%': high_price - 0.618 * diff,
+                '100.0%': low_price
+            }
+        else:
+            volatility = 0
+            current_close = 0
+            fib_levels = {}
+
+        return {
+            'symbol': ticker,
+            'price': current_close,
+            'rsi': current_rsi,
+            'ema_50': current_ema,
+            'ema_10': current_ema10,
+            'ema_5': current_ema5,
+            'sma_50': sma_50,
+            'sma_200': sma_200,
+            'rvol': rvol,
+            'atr': atr,
+            'macd_line': current_macd,
+            'macd_signal': current_signal_line,
+            'bb_upper': bb_upper,
+            'bb_lower': bb_lower,
+            'volatility_annual_pct': volatility.values[0] if hasattr(volatility, 'values') else volatility,
+            'fibonacci_levels': fib_levels
+        }
+
+    except Exception as e:
+        print(f"Error fetching technicals for {ticker}: {e}")
+        return None
diff --git a/templates/index.html b/templates/index.html
new file mode 100644
index 0000000..2e74d99
--- /dev/null
+++ b/templates/index.html
@@ -0,0 +1,890 @@
+<!DOCTYPE html>
+<html lang="en" data-theme="dark">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FinanceIQ — Multi-Asset Analytics Platform</title>
+    <meta name="description"
+        content="Professional multi-asset analytics: stocks, futures, options, currencies. DCF, Monte Carlo, AI insights, and live charting.">
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+    <link rel="stylesheet" href="/static/style.css">
+    <script src="https://unpkg.com/lightweight-charts@4.2.1/dist/lightweight-charts.standalone.production.js"></script>
+    <script src="https://unpkg.com/lucide@latest"></script>
+</head>
+
+<body>
+
+    <!-- ═══════════════════════════════════════════════════ -->
+    <!-- WELCOME PAGE                                       -->
+    <!-- ═══════════════════════════════════════════════════ -->
+    <div class="welcome-page" id="welcomePage">
+        <div class="welcome-bg"></div>
+        <div class="welcome-content">
+            <div class="welcome-logo">
+                <div class="welcome-icon-wrap">
+                    <i data-lucide="bar-chart-3" class="welcome-lucide-icon"></i>
+                </div>
+                <h1 class="welcome-title">FinanceIQ</h1>
+                <span class="badge-version">v5.2</span>
+            </div>
+            <p class="welcome-subtitle">Multi-Asset Intelligence Platform</p>
+            <p class="welcome-desc">
+                Stocks · Futures · Options · Currencies<br>
+                AI-powered analysis, live charts, DCF valuation, Monte Carlo forecasting, and institutional-grade
+                analytics.
+            </p>
+
+            <div class="welcome-features">
+                <div class="wf-card">
+                    <i data-lucide="candlestick-chart" class="wf-lucide"></i>
+                    <h3>Live Charts</h3>
+                    <p>Real-time candlestick charts with EMA, SMA, Bollinger, and drawing tools.</p>
+                </div>
+                <div class="wf-card">
+                    <i data-lucide="calculator" class="wf-lucide"></i>
+                    <h3>DCF Valuation</h3>
+                    <p>Intrinsic value via discounted cash flows, WACC, and terminal growth.</p>
+                </div>
+                <div class="wf-card">
+                    <i data-lucide="brain" class="wf-lucide"></i>
+                    <h3>AI Analyst</h3>
+                    <p>LLM-powered research synthesizing technicals, fundamentals, and sentiment.</p>
+                </div>
+                <div class="wf-card">
+                    <i data-lucide="trending-up" class="wf-lucide"></i>
+                    <h3>Monte Carlo</h3>
+                    <p>1,000-path probabilistic simulation with percentile bands.</p>
+                </div>
+                <div class="wf-card">
+                    <i data-lucide="target" class="wf-lucide"></i>
+                    <h3>Analyst Consensus</h3>
+                    <p>Live Wall Street ratings, price targets, and insider activity.</p>
+                </div>
+                <div class="wf-card">
+                    <i data-lucide="globe" class="wf-lucide"></i>
+                    <h3>Macro Intelligence</h3>
+                    <p>FRED indicators, sector heatmaps, correlation and peer analysis.</p>
+                </div>
+            </div>
+
+            <button class="welcome-cta" id="letsBeginBtn">
+                <i data-lucide="arrow-right" style="width:20px;height:20px;"></i>
+                <span>Get Started</span>
+            </button>
+            <p class="welcome-footer">FMP · Finnhub · FRED · Alpha Vantage · Ollama AI</p>
+        </div>
+    </div>
+
+    <!-- ═══════════════════════════════════════════════════ -->
+    <!-- MAIN APP                                           -->
+    <!-- ═══════════════════════════════════════════════════ -->
+    <div class="app-layout" id="mainApp" style="display:none;">
+
+        <!-- ── SIDEBAR ─────────────────────────────────── -->
+        <aside class="sidebar" id="sidebar">
+            <div class="sidebar-brand">
+                <i data-lucide="bar-chart-3" class="brand-icon"></i>
+                <span class="brand-text">FinanceIQ</span>
+                <span class="badge-version badge-sm">v5.2</span>
+            </div>
+
+            <nav class="sidebar-nav">
+                <div class="nav-group-label">Analysis</div>
+                <button class="nav-item active" data-tab="overview" data-asset="stocks,futures,options,currencies">
+                    <i data-lucide="layout-dashboard"></i>
+                    <span>Overview</span>
+                </button>
+                <button class="nav-item" data-tab="technical" data-asset="stocks,futures,currencies">
+                    <i data-lucide="activity"></i>
+                    <span>Technical</span>
+                </button>
+                <button class="nav-item" data-tab="fundamentals" data-asset="stocks">
+                    <i data-lucide="landmark"></i>
+                    <span>Fundamentals</span>
+                </button>
+                <button class="nav-item" data-tab="sentiment" data-asset="stocks,futures,options,currencies">
+                    <i data-lucide="heart-pulse"></i>
+                    <span>Sentiment</span>
+                </button>
+                <button class="nav-item" data-tab="options" data-asset="options">
+                    <i data-lucide="layers"></i>
+                    <span>Options</span>
+                </button>
+
+                <div class="nav-group-label">Research</div>
+                <button class="nav-item" data-tab="intelligence" data-asset="stocks,futures,options,currencies">
+                    <i data-lucide="sparkles"></i>
+                    <span>Intelligence</span>
+                </button>
+                <button class="nav-item" data-tab="macro" data-asset="stocks,futures">
+                    <i data-lucide="globe-2"></i>
+                    <span>Macro</span>
+                </button>
+
+                <div class="nav-group-label">Trading</div>
+                <button class="nav-item" data-tab="portfolio" data-asset="stocks,futures,options,currencies">
+                    <i data-lucide="briefcase"></i>
+                    <span>Portfolio</span>
+                </button>
+            </nav>
+
+            <div class="sidebar-bottom">
+                <button class="nav-item" id="themeToggle">
+                    <i data-lucide="moon" id="themeIcon"></i>
+                    <span id="themeLabel">Dark Mode</span>
+                </button>
+                <button class="nav-item" id="exportBtnSidebar" style="display:none;">
+                    <i data-lucide="download"></i>
+                    <span>Export Excel</span>
+                </button>
+            </div>
+        </aside>
+
+        <!-- ── MAIN CONTENT ────────────────────────────── -->
+        <main class="main-content">
+
+            <!-- Top Bar -->
+            <header class="topbar">
+                <button class="sidebar-toggle" id="sidebarToggle">
+                    <i data-lucide="menu"></i>
+                </button>
+
+                <div class="search-container">
+                    <!-- Asset Type Selector -->
+                    <div class="asset-selector">
+                        <button class="asset-btn active" data-asset="stocks">
+                            <i data-lucide="bar-chart-2"></i> Stocks
+                        </button>
+                        <button class="asset-btn" data-asset="futures">
+                            <i data-lucide="timer"></i> Futures
+                        </button>
+                        <button class="asset-btn" data-asset="options">
+                            <i data-lucide="layers"></i> Options
+                        </button>
+                        <button class="asset-btn" data-asset="currencies">
+                            <i data-lucide="coins"></i> Currencies
+                        </button>
+                    </div>
+
+                    <!-- Search Input -->
+                    <div class="search-input-group">
+                        <i data-lucide="search" class="search-icon"></i>
+                        <div class="ticker-wrapper">
+                            <input type="text" id="tickerInput" placeholder="Search ticker (e.g. AAPL, TSLA, NIFTY)"
+                                autocomplete="off">
+                            <div class="dropdown" id="dropdown"></div>
+                        </div>
+                        <select id="timeframeSelect" class="select-control">
+                            <option value="1Y">1 Year</option>
+                            <option value="6M">6 Months</option>
+                            <option value="3M">3 Months</option>
+                            <option value="1M">1 Month</option>
+                            <option value="5Y">5 Years</option>
+                            <option value="custom">Custom</option>
+                        </select>
+                        <select id="periodSelect" class="select-control">
+                            <option value="yearly">Annual</option>
+                            <option value="quarterly">Quarterly</option>
+                        </select>
+                        <select id="currencySelect" class="select-control">
+                            <option value="GBP">£ GBP</option>
+                            <option value="USD">$ USD</option>
+                            <option value="INR">₹ INR</option>
+                        </select>
+                        <button id="analyzeBtn" class="btn-primary">
+                            <i data-lucide="zap" style="width:16px;height:16px;"></i>
+                            Analyze
+                        </button>
+                    </div>
+                    <div class="custom-dates" id="customDates" style="display:none;">
+                        <label>From <input type="date" id="startDate"></label>
+                        <label>To <input type="date" id="endDate"></label>
+                    </div>
+                </div>
+            </header>
+
+            <!-- Loader -->
+            <div class="loader-overlay" id="loader" style="display:none">
+                <div class="loader-spinner"></div>
+                <p class="loader-text" id="loaderText">Analyzing...</p>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: OVERVIEW                               -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page active" id="page-overview">
+                <!-- ── Market Dashboard ── -->
+                <div class="market-dashboard" id="marketDashboard">
+                    <div class="dashboard-header">
+                        <h2 class="dashboard-title">
+                            <i data-lucide="globe" style="width:22px;height:22px;"></i>
+                            Market Pulse
+                            <span class="live-dot"></span>
+                        </h2>
+                        <span class="dashboard-subtitle">Live global market snapshot · Auto-refreshes every 60s</span>
+                    </div>
+                    <div class="dashboard-section">
+                        <h3 class="dash-section-title"><i data-lucide="trending-up" style="width:16px;height:16px;"></i>
+                            Global Indices</h3>
+                        <div class="market-grid" id="dashIndices">
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="dashboard-section">
+                        <h3 class="dash-section-title"><i data-lucide="gem" style="width:16px;height:16px;"></i>
+                            Commodities</h3>
+                        <div class="market-grid" id="dashCommodities">
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                        </div>
+                    </div>
+                    <div class="dashboard-section">
+                        <h3 class="dash-section-title"><i data-lucide="coins" style="width:16px;height:16px;"></i>
+                            Currency Pairs</h3>
+                        <div class="market-grid" id="dashCurrencies">
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                            <div class="market-card skeleton-card">
+                                <div class="skeleton-line"></div>
+                                <div class="skeleton-line short"></div>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+
+                <div class="results">
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="candlestick-chart"></i>
+                                Interactive Price Chart
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Candlestick chart with volume. Toggle overlays below to add EMA, SMA, Bollinger Bands, and Fibonacci levels.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="chart-controls" id="chartControls" style="display:none">
+                            <label class="chart-toggle"><input type="checkbox" id="togEma5"> EMA 5</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togEma10"> EMA 10</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togEma20"> EMA 20</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togSma200"> SMA 200</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togBb"> Bollinger</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togFib"> Fibonacci</label>
+                            <div class="custom-ema">
+                                <input type="number" id="customEmaPeriod" placeholder="Custom EMA" min="2" max="500">
+                                <button class="btn-sm" id="addCustomEma">Add</button>
+                            </div>
+                        </div>
+                        <div id="chartContainer"
+                            style="width:100%;height:420px;border-radius:var(--radius);overflow:hidden;"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="gauge"></i>
+                                Key Metrics
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Essential price and valuation metrics. RSI above 70 = overbought, below 30 = oversold.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="data-grid" id="keyMetrics"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="zap"></i>
+                                Quick Signal
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Algorithmic signal based on RSI, MACD, and moving average crossovers.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="quickSignal"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: TECHNICAL                              -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-technical">
+                <div class="results">
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="activity"></i>
+                                Technical Indicators
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="RSI (14-period), MACD trend direction, Bollinger Bands volatility measure.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="data-grid" id="technicalIndicators"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="scan-line"></i>
+                                Candlestick Patterns — Last 7 Days
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Patterns detected in the last 7 trading days with forward-looking predictions.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="patternOutlook" class="pattern-outlook-box"></div>
+                        <div id="candlestickPatterns" class="patterns-grid"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="calendar-check"></i>
+                                Earnings History (EPS)
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Quarterly EPS — Actual vs Estimate. Consistent beats are bullish.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="earningsTable" class="table-container"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: FUNDAMENTALS                           -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-fundamentals">
+                <div class="results">
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="landmark"></i>
+                                DCF Intrinsic Valuation
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="DCF projects future FCF, discounts by WACC, and derives intrinsic value. Intrinsic > price = undervalued.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="dcfValuation"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="shield-check"></i>
+                                Altman Z-Score
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Bankruptcy risk. Z > 2.99 = Safe, 1.81-2.99 = Grey Zone, < 1.81 = Distress.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="zScore"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="banknote"></i>
+                                Dividend Analysis
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Dividend yield, payout ratio, and history. Payout > 80% may be unsustainable.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="dividendAnalysis"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="file-text"></i>
+                                Income Statement
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Revenue, operating income, and net income from the latest filings.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="data-grid" id="incomeStatement"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="pie-chart"></i>
+                                Ratios & Valuation
+                            </div>
+                            <span class="info-icon" data-tooltip="P/E, EV/EBITDA, ROE and other valuation multiples.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="data-grid" id="ratiosGrid"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="wallet"></i>
+                                Free Cash Flow
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Cash available after CapEx. Strong FCF = flexibility for dividends and buybacks.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="data-grid" id="fcffGrid"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: SENTIMENT                              -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-sentiment">
+                <div class="results">
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="heart-pulse"></i>
+                                Fear & Greed Index
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="CNN Fear & Greed (0-100). Extreme Fear (<25) = buying opportunity.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="fearGreedGauge"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="triangle-alert"></i>
+                                VIX Volatility Index
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="VIX < 15 = calm, 15-25 = normal, 25-35 = elevated, > 35 = panic.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="vixDisplay"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="newspaper"></i>
+                                News Sentiment (VADER)
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Headlines analyzed with VADER. Compound score -1 to +1.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="newsSection"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: INTELLIGENCE                           -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-intelligence">
+                <div class="results">
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="target"></i>
+                                Analyst Ratings & Price Target
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Wall Street consensus from Finnhub. Buy vs Hold vs Sell counts and price target range.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="analystRatings"></div>
+                    </div>
+                    <div class="card">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="eye"></i>
+                                Insider Trading Activity
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Recent SEC insider filings. Insider buying is often bullish.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="insiderTrading"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="trending-up"></i>
+                                Monte Carlo Price Forecast (60-Day)
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="1,000 random simulations based on historical volatility. Toggle percentile bands below.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="mc-band-controls" id="mcBandControls">
+                            <label class="chart-toggle"><input type="checkbox" id="togP90" checked> P90 (Bull)</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togP75" checked> P75</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togP50" checked> P50
+                                (Median)</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togP25" checked> P25</label>
+                            <label class="chart-toggle"><input type="checkbox" id="togP10" checked> P10 (Bear)</label>
+                        </div>
+                        <div id="monteCarloChart"
+                            style="width:100%;height:340px;border-radius:var(--radius);overflow:hidden;"></div>
+                        <div id="monteCarloStats" class="mc-stats"></div>
+                    </div>
+                    <div class="card card-full card-ai">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="sparkles"></i>
+                                AI Analyst
+                                <span class="badge-ai">Ollama</span>
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Local AI analysis via Ollama (Llama 3.1). Synthesizes all data for Buy/Hold/Sell.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="ai-content" id="aiContent">
+                            <p class="ai-placeholder">Run analysis first, then AI commentary will appear here.</p>
+                        </div>
+                        <div class="ai-actions">
+                            <input class="ai-input" id="aiInput" placeholder="Ask a follow-up question...">
+                            <button class="btn-primary btn-sm" id="askAi">
+                                <i data-lucide="send" style="width:14px;height:14px;"></i> Ask
+                            </button>
+                        </div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: MACRO                                  -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-macro">
+                <div class="results">
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="landmark"></i>
+                                Economic Indicators (FRED)
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Live macro data from the Federal Reserve. Hover to see impact.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="data-grid" id="macroIndicators"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="grid-3x3"></i>
+                                Sector Performance Heatmap
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="S&P 500 sector performance. Green = outperforming, Red = underperforming.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div class="heatmap-controls" id="heatmapControls"></div>
+                        <div id="sectorHeatmap" class="heatmap-grid"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="link"></i>
+                                Correlation Matrix
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Daily return correlation with benchmarks (SPY, QQQ, DIA, Gold, Bonds, VIX).">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="correlationMatrix" class="corr-matrix"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="building-2"></i>
+                                Competitor Analysis
+                            </div>
+                            <span class="info-icon"
+                                data-tooltip="Compares key ratios with sector peers. Analyzed stock is highlighted.">
+                                <i data-lucide="info" style="width:14px;height:14px;"></i>
+                            </span>
+                        </div>
+                        <div id="compSection" class="comp-container"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: OPTIONS                                -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-options">
+                <div class="results">
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="layers"></i>
+                                Options Chain
+                            </div>
+                            <div class="options-controls">
+                                <select id="optExpiry" class="select-control"></select>
+                                <button class="btn-sm btn-primary" id="loadChainBtn">Load Chain</button>
+                            </div>
+                        </div>
+                        <div class="options-toggle">
+                            <button class="heatmap-btn active" data-chain="calls">Calls</button>
+                            <button class="heatmap-btn" data-chain="puts">Puts</button>
+                        </div>
+                        <div id="optionsChainTable" class="table-container"></div>
+                    </div>
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="trending-up"></i>
+                                Options Payoff Diagram
+                            </div>
+                        </div>
+                        <div class="payoff-controls">
+                            <label>Strike: <input type="number" id="payoffStrike" class="input-sm" value="100"></label>
+                            <label>Premium: <input type="number" id="payoffPremium" class="input-sm" value="5"
+                                    step="0.5"></label>
+                            <select id="payoffType" class="select-control">
+                                <option value="call">Call</option>
+                                <option value="put">Put</option>
+                            </select>
+                            <select id="payoffDirection" class="select-control">
+                                <option value="long">Long</option>
+                                <option value="short">Short</option>
+                            </select>
+                            <button class="btn-sm btn-primary" id="drawPayoffBtn">Draw</button>
+                        </div>
+                        <div id="payoffChart" style="width:100%;height:300px;"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- ═══════════════════════════════════════════ -->
+            <!-- TAB: PORTFOLIO                              -->
+            <!-- ═══════════════════════════════════════════ -->
+            <div class="tab-page" id="page-portfolio">
+                <div class="results">
+                    <!-- Portfolio Summary -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="briefcase"></i>
+                                Portfolio Summary
+                                <span class="live-dot"></span>
+                            </div>
+                            <div style="display:flex;gap:8px;align-items:center;">
+                                <span class="badge-sm" id="pfSlippageLabel" title="Slippage">Slip: 5 bps</span>
+                                <span class="badge-sm" id="pfCommLabel" title="Commission">Comm: $0.005/sh</span>
+                                <button class="btn-sm btn-danger" id="resetPortfolioBtn" title="Reset to $100K">
+                                    <i data-lucide="rotate-ccw" style="width:14px;height:14px;"></i> Reset
+                                </button>
+                            </div>
+                        </div>
+                        <div class="portfolio-summary-grid" id="portfolioSummary">
+                            <div class="data-item">
+                                <div class="data-label">Total Value</div>
+                                <div class="data-value" id="pfTotalValue">$100,000.00</div>
+                            </div>
+                            <div class="data-item">
+                                <div class="data-label">Cash</div>
+                                <div class="data-value" id="pfCash">$100,000.00</div>
+                            </div>
+                            <div class="data-item">
+                                <div class="data-label">Buying Power</div>
+                                <div class="data-value" id="pfBuyingPower">$100,000.00</div>
+                            </div>
+                            <div class="data-item">
+                                <div class="data-label">Positions</div>
+                                <div class="data-value" id="pfPositionsValue">$0.00</div>
+                            </div>
+                            <div class="data-item">
+                                <div class="data-label">Margin Used</div>
+                                <div class="data-value" id="pfMarginUsed">$0.00</div>
+                            </div>
+                            <div class="data-item">
+                                <div class="data-label">P&L</div>
+                                <div class="data-value" id="pfPnL">$0.00</div>
+                            </div>
+                            <div class="data-item">
+                                <div class="data-label">Return</div>
+                                <div class="data-value" id="pfReturnPct">0.00%</div>
+                            </div>
+                        </div>
+                    </div>
+
+                    <!-- Equity Curve -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="line-chart"></i>
+                                Equity Curve
+                            </div>
+                        </div>
+                        <div id="equityCurveContainer"
+                            style="width:100%;height:260px;border-radius:var(--radius);overflow:hidden;"></div>
+                    </div>
+
+                    <!-- Trade Form -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="arrow-left-right"></i>
+                                Trade Terminal
+                            </div>
+                        </div>
+                        <div class="trade-form">
+                            <div class="trade-search-wrap">
+                                <input type="text" id="tradeTicker" placeholder="Search ticker..." class="input-sm"
+                                    autocomplete="off">
+                                <div class="trade-dropdown" id="tradeDropdown"></div>
+                            </div>
+                            <input type="number" id="tradeShares" placeholder="Qty" min="0.01" step="0.01"
+                                class="input-sm" style="width:90px;">
+                            <select id="tradeOrderType" class="input-sm" style="width:110px;">
+                                <option value="market">Market</option>
+                                <option value="limit">Limit</option>
+                                <option value="stop">Stop</option>
+                            </select>
+                            <input type="number" id="tradeLimitPrice" placeholder="Price" step="0.01" class="input-sm"
+                                style="width:100px;display:none;">
+                            <select id="tradeAssetType" class="input-sm" style="width:100px;">
+                                <option value="stock">Stock</option>
+                                <option value="futures">Futures</option>
+                                <option value="currency">Currency</option>
+                            </select>
+                            <div class="trade-btn-group">
+                                <button class="btn-trade btn-buy" id="buyBtn">Buy Long</button>
+                                <button class="btn-trade btn-sell" id="sellBtn">Sell</button>
+                                <button class="btn-trade btn-short" id="shortBtn">Short</button>
+                                <button class="btn-trade btn-cover" id="coverBtn">Cover</button>
+                            </div>
+                        </div>
+                        <div id="tradeResult" class="trade-result"></div>
+                    </div>
+
+                    <!-- Pending Orders -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="clock"></i>
+                                Pending Orders
+                            </div>
+                        </div>
+                        <div id="pendingOrdersTable" class="table-container"></div>
+                    </div>
+
+                    <!-- Positions Table -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="list"></i>
+                                Positions
+                            </div>
+                        </div>
+                        <div id="positionsTable" class="table-container"></div>
+                    </div>
+
+                    <!-- Analytics -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="bar-chart-3"></i>
+                                Performance Analytics
+                            </div>
+                        </div>
+                        <div class="portfolio-analytics-grid" id="portfolioAnalytics"></div>
+                    </div>
+
+                    <!-- Transaction History -->
+                    <div class="card card-full">
+                        <div class="card-header">
+                            <div class="card-title">
+                                <i data-lucide="scroll-text"></i>
+                                Transaction History
+                            </div>
+                        </div>
+                        <div id="transactionHistory" class="table-container"></div>
+                    </div>
+                </div>
+            </div>
+
+            <!-- Footer -->
+            <footer class="footer">
+                <p>FinanceIQ v5.2 · FMP · Finnhub · FRED · Alpha Vantage · Ollama AI · Paper Trading · Educational
+                    purposes only</p>
+            </footer>
+        </main>
+    </div>
+
+    <script src="/static/script.js"></script>
+    <script>lucide.createIcons();</script>
+</body>
+
+</html>
\ No newline at end of file
diff --git a/test_intraday.py b/test_intraday.py
new file mode 100644
index 0000000..72ddb7e
--- /dev/null
+++ b/test_intraday.py
@@ -0,0 +1,19 @@
+from financetoolkit import Toolkit
+
+API_KEY = "wybWEsp1oB9abHfz3yPpQYwffxaN21B7"
+TICKER = "NVDA"
+
+try:
+    companies = Toolkit(tickers=[TICKER], api_key=API_KEY)
+    # Try fetching intraday
+    print("Attempting to fetch 1min data...")
+    # Note: verify correct method for intraday in financetoolkit
+    # Usually get_intraday_data or similar, or interval argument in get_historical_data
+    # Looking at docs/usage from memory or previous files:
+    # get_historical_data(period="daily") was used.
+    # Let's try interval='1m' if supported.
+    intra = companies.get_historical_data(period="1m") # Guessing '1m' is period
+    print(intra.head())
+    print("Success!")
+except Exception as e:
+    print(f"Failed: {e}")
diff --git a/test_news.py b/test_news.py
new file mode 100644
index 0000000..94a51a2
--- /dev/null
+++ b/test_news.py
@@ -0,0 +1,27 @@
+import feedparser
+from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
+
+try:
+    # Test Feed: Google News for AAPL
+    rss_url = "https://news.google.com/rss/search?q=AAPL&hl=en-US&gl=US&ceid=US:en"
+    print(f"Fetching RSS from: {rss_url}")
+    
+    feed = feedparser.parse(rss_url)
+    
+    # feedparser doesn't always return .status for local files or some responses, but usually does for HTTP
+    # We check if entries are present
+    print(f"Entries found: {len(feed.entries)}")
+
+    if feed.entries:
+        title = feed.entries[0].title
+        print(f"Sample Title: {title}")
+        
+        analyzer = SentimentIntensityAnalyzer()
+        score = analyzer.polarity_scores(title)
+        print(f"Sentiment: {score}")
+        print("✅ News + Sentiment Test PASSED")
+    else:
+        print("❌ No entries found in RSS feed")
+
+except Exception as e:
+    print(f"❌ Test FAILED with error: {e}")