Deploy: SentinelAI clean build — post-cleanup

.gitignore

@@ -0,0 +1,68 @@
+# ── Virtual Environment ───────────────────────────────────────────────────────
+env/
+venv/
+.venv/
+.env
+
+# ── Python cache ──────────────────────────────────────────────────────────────
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+
+# ── OS files ──────────────────────────────────────────────────────────────────
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# ── IDE / Editor ──────────────────────────────────────────────────────────────
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# ── PDF output (generated at runtime) ────────────────────────────────────────
+SentinelAI_Report.pdf
+*.pdf
+
+# ── Model weights (too large for GitHub — hosted on HuggingFace Hub) ─────────
+# Local model directories, if ever recreated, should not be committed.
+models/sentinel_model/model.safetensors
+scam_model/
+
+# ── Training checkpoints & artifacts ─────────────────────────────────────────
+models/results/
+results/
+*.pt
+optimizer.pt
+rng_state.pth
+trainer_state.json
+training_args.bin
+
+# ── Logs ──────────────────────────────────────────────────────────────────────
+*.log
+logs/
+
+# ── Jupyter ───────────────────────────────────────────────────────────────────
+.ipynb_checkpoints/
+*.ipynb
+
+# ── Test / Coverage ───────────────────────────────────────────────────────────
+.pytest_cache/
+htmlcov/
+.coverage
+
+# ── Dev / Debug scripts (keep locally, don't push) ───────────────────────────
+app/eval.py
+app/datas.py
+app/texting.py
+app/diagnose_model.py
+app/test_predictions.py
+
+# ── Pitch deck / presentation files ──────────────────────────────────────────
+*.pptx
+SentinelAI_PitchDeck.pdf
+
+# ── Dataset files (large, keep locally — not for version control) ─────────────
+data/*.csv
+*.csv

Dockerfile

@@ -0,0 +1,31 @@
+# -- 1. Base image -- slim Python 3.11 on Linux
+FROM python:3.11-slim
+
+# -- 2. Set working directory inside the container
+WORKDIR /app
+
+# -- 3. Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+# -- 4. Copy requirements first (Docker layer caching)
+COPY requirements.txt .
+
+# -- 5. Install PyTorch CPU-only FIRST (much smaller, ~200MB vs 2GB)
+RUN pip install --no-cache-dir torch==2.2.2+cpu --index-url https://download.pytorch.org/whl/cpu
+
+# -- 6. Install remaining Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# -- 7. Copy the entire project into the container
+COPY . .
+
+# -- 8. HuggingFace Spaces requires port 7860
+EXPOSE 7860
+
+# -- 9. Start the app
+CMD ["python", "app/app.py"]

README.md

@@ -0,0 +1,383 @@
+---
+title: SentinelAI
+emoji: 🛡️
+colorFrom: blue
+colorTo: red
+sdk: docker
+pinned: false
+---
+
+<div align="center">
+
+# 🛡️ SentinelAI
+
+### AI-Powered Digital Threat Intelligence Engine
+
+*Detect scams. Quantify risk. Generate intelligence briefs.*
+
+[![Python](https://img.shields.io/badge/Python-3.10+-3776AB?style=flat-square&logo=python&logoColor=white)](https://python.org)
+[![Flask](https://img.shields.io/badge/Flask-3.0-000000?style=flat-square&logo=flask&logoColor=white)](https://flask.palletsprojects.com)
+[![Transformers](https://img.shields.io/badge/HuggingFace-DistilBERT-FFD21E?style=flat-square&logo=huggingface&logoColor=black)](https://huggingface.co)
+[![PyTorch](https://img.shields.io/badge/PyTorch-2.2-EE4C2C?style=flat-square&logo=pytorch&logoColor=white)](https://pytorch.org)
+[![Accuracy](https://img.shields.io/badge/Accuracy-97.42%25-22C55E?style=flat-square)](/)
+[![F1 Score](https://img.shields.io/badge/F1_Score-97.59%25-22C55E?style=flat-square)](/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-22D3EE?style=flat-square)](LICENSE)
+
+</div>
+
+---
+
+## 📋 Overview
+
+**SentinelAI** is a real-time digital threat analysis system that uses a **fine-tuned DistilBERT transformer** combined with **rule-based heuristic pre-filtering** to detect digital arrest scams, phishing attempts, and financial fraud in text messages.
+
+The system features:
+- A **hybrid inference pipeline** (rules + neural network) achieving **97.42% accuracy**
+- A **tactical HUD-style frontend** with animated score visualizations and threat indicator chips
+- A **downloadable PDF intelligence brief** formatted like a professional security document
+
+---
+
+## 🖥️ UI Preview
+
+> Dark-themed tactical HUD with animated SVG score arc, threat indicator chips, OCR image upload, and a downloadable intelligence brief.
+
+---
+
+## 🧠 Model Performance
+
+The DistilBERT model was fine-tuned on a **curated digital arrest scam corpus** and evaluated on a held-out test set of **155 samples**.
+
+### Final Evaluation Metrics
+
+| Metric | Score |
+|---|---|
+| **Accuracy** | **97.42%** |
+| **F1 Score** | **97.59%** |
+| **Precision** | **97.59%** |
+| **Recall** | **97.59%** |
+
+### Confusion Matrix
+
+| | Predicted SAFE | Predicted SCAM |
+|---|---|---|
+| **Actual SAFE** | 70 | 2 |
+| **Actual SCAM** | 2 | 81 |
+
+> Out of 155 test samples, the model produced only **4 misclassifications** (2 false positives + 2 false negatives), achieving a near-perfect detection rate.
+
+### Key Takeaways
+- **False Positive Rate**: 2.78% — only 2 out of 72 safe messages were incorrectly flagged
+- **False Negative Rate**: 2.41% — only 2 out of 83 scam messages were missed
+- **Balanced performance**: Equal precision and recall indicate the model doesn't bias toward either class
+
+---
+
+## ✨ Features
+
+| Feature | Description |
+|---|---|
+| 🤖 **Fine-Tuned DistilBERT** | Transformer model trained on curated digital scam corpus with 97.42% accuracy |
+| ⚡ **Hybrid Inference Engine** | Rule-based pre-screening (10 signal patterns) + neural network fallback |
+| 🎯 **Real-Time Risk Scoring** | Probabilistic scam/safe scoring with HIGH / MEDIUM / LOW classification |
+| 🔍 **Signal Extraction** | Names specific scam tactics detected (authority threats, urgency pressure, etc.) |
+| 🖥️ **Tactical HUD Interface** | Dark-themed dashboard with animated SVG score arcs and threat indicator chips |
+| 📄 **PDF Intelligence Brief** | Professional SIB-format report with risk bands, signal tables, and action items |
+| ⌨️ **Keyboard Shortcuts** | Ctrl+Enter to run analysis |
+
+---
+
+## 🏗️ System Architecture
+
+```mermaid
+flowchart TD
+    A["👤 User\nPastes suspicious message"] --> B["🌐 Flask Web App\napp.py"]
+
+    B --> C["🔍 Hybrid Inference Engine\ninference.py"]
+
+    C --> D{"Rule-Based\nPre-filter"}
+    D -->|"≥2 scam signals matched"| E["🔴 HIGH RISK\nReturn immediately"]
+    D -->|"Safe keywords matched"| F["🟢 LOW RISK\nReturn immediately"]
+    D -->|"Ambiguous"| G["🤖 DistilBERT Model\nsentinel_model/"]
+
+    G --> H["Softmax Probabilities\nSCAM vs SAFE"]
+    H --> I["Probability Adjustment\nvia rule scores"]
+    I --> J["Final Classification\n+ risk_level + signals"]
+
+    E --> K["📡 JSON Response\nto Frontend"]
+    F --> K
+    J --> K
+
+    K --> L["🖥️ Tactical HUD UI\nScore arc + threat chips"]
+    L --> M{"User clicks\nDownload Brief?"}
+    M -->|Yes| N["📄 pdf_generator.py\nStructured Intelligence Brief"]
+    N --> O["⬇️ PDF Download\nSentinelAI_Report.pdf"]
+```
+
+---
+
+## 🔬 Inference Pipeline
+
+```mermaid
+sequenceDiagram
+    participant U as User
+    participant F as Flask API
+    participant R as Rule Engine
+    participant M as DistilBERT Model
+    participant P as PDF Generator
+
+    U->>F: POST /analyze { message }
+    F->>R: Check 10 scam signal patterns
+    alt ≥2 patterns matched
+        R-->>F: HIGH RISK + matched signals
+    else Safe keywords found
+        R-->>F: LOW RISK + empty signals
+    else Ambiguous
+        R->>M: Tokenize + forward pass
+        M-->>R: Softmax probabilities
+        R-->>F: Adjusted label + risk_level + signals
+    end
+    F-->>U: JSON { label, scam_probability, risk_level, signals }
+
+    U->>F: POST /download_report { analysis data }
+    F->>P: generate_pdf(data, filepath)
+    P-->>F: SentinelAI_Report.pdf
+    F-->>U: PDF file download
+```
+
+---
+
+## 🔬 Technical Deep Dive
+
+### Hybrid Inference Strategy
+
+The inference engine uses a **two-stage approach** to maximize both speed and accuracy:
+
+**Stage 1 — Rule-Based Pre-filter** (instant, zero-cost):
+- Scans the input against **10 regex-based scam signal patterns**
+- If ≥2 patterns match → immediately returns `HIGH RISK` (no model inference needed)
+- If safe keywords match and no scam signals → immediately returns `LOW RISK`
+- This handles clear-cut cases in **<1ms** without loading the model
+
+**Stage 2 — Neural Network** (for ambiguous cases):
+- Tokenizes the input using DistilBERT's WordPiece tokenizer
+- Performs a forward pass through the fine-tuned model
+- Applies softmax to get SCAM vs SAFE probabilities
+- Adjusts probabilities using partial rule scores for better calibration
+
+### Detected Scam Signal Categories
+
+| # | Signal | Example Pattern |
+|---|---|---|
+| 1 | Arrest / legal authority threat | *"FBI warrant", "CBI enforcement"* |
+| 2 | Urgency / time pressure | *"immediate", "within 2 hours"* |
+| 3 | Payment demand with urgency | *"transfer funds now"* |
+| 4 | Phishing link / click-bait | *"click here to verify"* |
+| 5 | Account suspension threat | *"your account is frozen"* |
+| 6 | Prize / lottery scam | *"you have won a prize"* |
+| 7 | Credential / remote access request | *"share OTP", "install AnyDesk"* |
+| 8 | Digital arrest pattern | *"stay on the line"* |
+| 9 | Isolation / secrecy demand | *"do not tell anyone"* |
+| 10 | Document / ID fraud | *"your Aadhaar is blocked"* |
+
+---
+
+## 📁 Project Structure
+
+```
+Sentinel/
+│
+├── app/
+│   ├── app.py                  # Flask routes: /, /analyze, /ocr_analyze, /download_report
+│   ├── inference.py            # Hybrid prediction engine (rules + DistilBERT)
+│   ├── ocr.py                  # Image → text extraction via Tesseract
+│   ├── pdf_generator.py        # Structured Intelligence Brief PDF generator
+│   └── templates/
+│       └── index.html          # Tactical HUD SPA (Tailwind CSS, dark theme)
+│
+├── models/
+│   └── train_model_v2.py       # Training script (for reference — model on HuggingFace)
+│
+├── data/
+│   └── sentinel_dataset_v3_final.csv   # Final training dataset (14,000 rows, 60:40 ratio)
+│
+├── Dockerfile                  # HuggingFace Spaces deployment (port 7860)
+├── requirements.txt
+├── .gitignore
+└── README.md
+```
+
+> ⚠️ The trained model weights are **not stored locally** — they are loaded directly from
+> [`Shade63/sentinel-model`](https://huggingface.co/Shade63/sentinel-model) on HuggingFace Hub.
+
+---
+
+## 🛠️ Tech Stack
+
+| Layer | Technology | Purpose |
+|---|---|---|
+| **ML Model** | DistilBERT (HuggingFace Transformers) | Fine-tuned binary classifier for scam detection |
+| **ML Framework** | PyTorch 2.2 | Tensor operations and model inference |
+| **Backend** | Flask 3.0 | REST API serving `/analyze` and `/download_report` |
+| **Frontend** | HTML + Tailwind CSS + Vanilla JS | Tactical HUD single-page application |
+| **PDF Engine** | ReportLab 4.1 | Generates dark-themed Structured Intelligence Briefs |
+| **Data Processing** | Pandas + scikit-learn | Dataset management and evaluation metrics |
+
+---
+
+## ⚙️ Setup & Installation
+
+### Prerequisites
+- Python 3.10+
+- pip
+
+### 1. Clone the repository
+```bash
+git clone https://github.com/Shade-63/Sentinel.git
+cd Sentinel
+```
+
+### 2. Create and activate a virtual environment
+```bash
+python -m venv env
+
+# Windows
+env\Scripts\activate
+
+# macOS / Linux
+source env/bin/activate
+```
+
+### 3. Install dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Download the model weights
+
+> ⚠️ `model.safetensors` (~255 MB) is **not included** in this repo due to GitHub's 100 MB file limit.
+
+**Option A — From Releases** *(recommended)*
+Download `model.safetensors` from the [Releases page](../../releases) and place it at:
+```
+models/sentinel_model/model.safetensors
+```
+
+**Option B — Train from scratch**
+```bash
+cd models
+python train_model_v2.py
+```
+
+### 5. Run the application
+```bash
+cd app
+python app.py
+```
+
+Open **http://127.0.0.1:7860** in your browser.
+
+---
+
+## 🔌 API Reference
+
+### `POST /analyze`
+
+Analyzes a text message for scam indicators.
+
+**Request:**
+```json
+{
+  "message": "FBI warrant arrest immediate payment"
+}
+```
+
+**Response:**
+```json
+{
+  "label": "SCAM",
+  "scam_probability": 0.99,
+  "safe_probability": 0.01,
+  "risk_level": "HIGH",
+  "signals": [
+    "Arrest or legal authority threat",
+    "Urgency / time pressure",
+    "Payment demand with urgency"
+  ]
+}
+```
+
+### `POST /download_report`
+
+Generates and returns a PDF Structured Intelligence Brief.
+
+**Request:**
+```json
+{
+  "message": "...",
+  "risk_score": "99.0",
+  "risk_level": "HIGH",
+  "signals": ["Arrest or legal authority threat"]
+}
+```
+
+**Response:** Binary PDF file download
+
+---
+
+## 📄 PDF Report — Structured Intelligence Brief
+
+After analysis, click **DOWNLOAD INTELLIGENCE BRIEF** to get a formatted SIB containing:
+
+```
+┌──────────────────────────────────────────────────────────┐
+│  SENTINELAI  ·  STRUCTURED INTELLIGENCE BRIEF            │
+│  Report ID: SIB-20260320-170900   Generated: 20 Mar 2026 │
+├──────────────────────────────────────────────────────────┤
+│  ⬛ THREAT INTELLIGENCE REPORT — CONFIDENTIAL            │
+├──────────────┬──────────────┬──────────────┬─────────────┤
+│ CLASSIFICATION│ REPORT TYPE │ ENGINE       │ TIMESTAMP   │
+├──────────────┴──────────────┴──────────────┴─────────────┤
+│                                                          │
+│   🔴 HIGH RISK — SCAM DETECTED      99.0%                │
+│   █████████████████████████████████░ progress bar         │
+│                                                          │
+├──────────────────────────────────────────────────────────┤
+│  01 · INTERCEPTED COMMUNICATION                          │
+│  02 · DETECTED RISK INDICATORS      (numbered table)     │
+│  03 · AI MODEL INTERPRETATION       (key-value table)    │
+│  04 · RECOMMENDED IMMEDIATE ACTIONS (CRITICAL/HIGH/MED)  │
+├──────────────────────────────────────────────────────────┤
+│  CONFIDENTIAL — FOR AUTHORIZED USE ONLY    Page 1        │
+└──────────────────────────────────────────────────────────┘
+```
+
+---
+
+## 🚀 What Makes This Different
+
+| Aspect | SentinelAI | Simple Keyword Matching |
+|---|---|---|
+| **Detection Method** | Fine-tuned transformer + rule engine | Static keyword lists |
+| **Accuracy** | 97.42% | ~70% (high false-positive rate) |
+| **Context Understanding** | Understands sentence-level semantics | Matches isolated words |
+| **Signal Extraction** | Names specific tactics used | No explanation |
+| **Risk Quantification** | Probabilistic score (0-100%) | Binary yes/no |
+| **Output** | Professional PDF intelligence brief | Plain text alert |
+
+---
+
+## ⚠️ Disclaimer
+
+SentinelAI provides AI-based probabilistic risk estimation and does **not** constitute legal advice. All findings are based on pattern recognition and should be verified through official law enforcement or financial authorities. This tool is intended for educational and informational purposes only.
+
+---
+
+<div align="center">
+
+**Built with** Flask · HuggingFace Transformers · PyTorch · ReportLab
+
+*Protecting innocents from digital threats through AI-powered intelligence*
+
+</div>
+

app/app.py

@@ -0,0 +1,90 @@
+from flask import Flask, render_template, request, jsonify, send_file
+from inference import predict
+from pdf_generator import generate_pdf
+from ocr import extract_text_from_image, allowed_file
+import os
+import tempfile
+
+app = Flask(__name__)
+
+# Limit incoming request body to 15 MB (guards /ocr_analyze against huge uploads)
+app.config["MAX_CONTENT_LENGTH"] = 15 * 1024 * 1024
+
+
+@app.route("/")
+def home():
+    return render_template("index.html")
+
+
+@app.route("/analyze", methods=["POST"])
+def analyze():
+    data = request.get_json(silent=True)
+
+    if not data or not data.get("message"):
+        return jsonify({"error": "No message provided."}), 400
+
+    text = data["message"].strip()
+    if not text:
+        return jsonify({"error": "Message cannot be empty."}), 400
+
+    result = predict(text)
+    return jsonify(result)
+
+
+@app.route("/ocr_analyze", methods=["POST"])
+def ocr_analyze():
+    if "image" not in request.files:
+        return jsonify({"error": "No image uploaded."}), 400
+
+    file = request.files["image"]
+
+    if file.filename == "":
+        return jsonify({"error": "No file selected."}), 400
+
+    if not allowed_file(file.filename):
+        return jsonify({"error": "Unsupported file type. Use PNG, JPG, JPEG, WEBP, or BMP."}), 400
+
+    file_bytes = file.read()
+    ocr_result = extract_text_from_image(file_bytes)
+
+    if not ocr_result["success"]:
+        return jsonify({"error": ocr_result["error"]}), 422
+
+    extracted_text = ocr_result["text"]
+
+    # Pipe directly into existing inference — zero changes to inference.py
+    prediction = predict(extracted_text)
+    prediction["extracted_text"] = extracted_text
+    prediction["input_method"] = "ocr"
+
+    return jsonify(prediction)
+
+
+@app.route("/download_report", methods=["POST"])
+def download_report():
+    data = request.get_json(silent=True)
+    if not data:
+        return jsonify({"error": "No data provided."}), 400
+
+    # Use a temp file so concurrent requests don't overwrite each other
+    with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
+        filepath = tmp.name
+
+    try:
+        generate_pdf(data, filepath)
+        return send_file(
+            filepath,
+            as_attachment=True,
+            mimetype="application/pdf",
+            download_name="SentinelAI_Report.pdf",
+        )
+    finally:
+        # Clean up the temp file after Flask sends it
+        try:
+            os.unlink(filepath)
+        except OSError:
+            pass
+
+
+if __name__ == "__main__":
+    app.run(host="0.0.0.0", port=7860, debug=False)

app/inference.py

@@ -0,0 +1,105 @@
+import torch
+import os
+import re
+from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification
+
+# Changed: load from HuggingFace Hub instead of local path
+tokenizer = DistilBertTokenizerFast.from_pretrained("Shade63/sentinel-model")
+model = DistilBertForSequenceClassification.from_pretrained("Shade63/sentinel-model")
+model.eval()
+
+# Rule-based scam indicators (high confidence patterns)
+SCAM_SIGNAL_LABELS = [
+    ("arrest or legal authority threat", r'\b(arrest|warrant|fbi|cbi|irs|enforcement|legal action)\b'),
+    ("urgency / time pressure",          r'\b(urgent|immediate|now|today|within \d+ (hours?|minutes?))\b'),
+    ("payment demand with urgency",      r'\b(pay|payment|transfer|wire|funds?|money)\b.*\b(immediate|now|urgent)\b'),
+    ("phishing link / click-bait",       r'\b(click|verify|confirm).*\b(link|here|now)\b'),
+    ("account suspension threat",        r'\b(suspended|blocked|frozen|invalid).*\b(account|card|number)\b'),
+    ("prize / lottery scam",             r'\b(won|prize|lottery|claim)\b'),
+    ("credential / remote access request", r'\b(otp|password|remote access|teamviewer|anydesk)\b'),
+    ("digital arrest pattern",           r'\b(digital arrest|stay on (the )?line)\b'),
+    ("isolation / secrecy demand",       r'\b(do not (disconnect|tell|go to))\b'),
+    ("document / ID fraud",              r'\b(aadhaar|sim|passport|visa).*\b(illegal|invalid|blocked)\b'),
+]
+
+SAFE_KEYWORDS = [
+    r'\b(official public advisory|government agencies do not)\b',
+    r'\b(legitimate authority|verifiable credentials)\b',
+    r'\b(official portal|registered mail|written documentation)\b',
+    r'\b(meeting|agenda|schedule|call|project)\b',
+    r'\b(hello|hi|how are you)\b',
+]
+
+
+def predict(text):
+    text_lower = text.lower()
+
+
+    # Rule-based scoring
+    scam_score = 0
+    safe_score = 0
+    matched_signals = []
+
+    for label, pattern in SCAM_SIGNAL_LABELS:
+        if re.search(pattern, text_lower, re.IGNORECASE):
+            scam_score += 1
+            matched_signals.append(label.capitalize())
+
+    for pattern in SAFE_KEYWORDS:
+        if re.search(pattern, text_lower, re.IGNORECASE):
+            safe_score += 1
+
+    # If strong rule-based signal, use it
+    if scam_score >= 2:
+        scam_prob = min(0.85 + (scam_score * 0.05), 0.99)
+        safe_prob = max(0.15 - (scam_score * 0.05), 0.01)
+        return {
+            "label": "SCAM",
+            "scam_probability": round(scam_prob, 4),
+            "safe_probability": round(safe_prob, 4),
+            "risk_level": "HIGH",
+            "signals": matched_signals,
+        }
+    elif safe_score >= 1 and scam_score == 0:
+        return {
+            "label": "SAFE",
+            "scam_probability": 0.15,
+            "safe_probability": 0.85,
+            "risk_level": "LOW",
+            "signals": [],
+        }
+
+    # Otherwise, use model prediction
+    inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+
+    with torch.no_grad():
+        outputs = model(**inputs)
+
+    logits = outputs.logits
+    probabilities = torch.softmax(logits, dim=1)
+
+    scam_prob = probabilities[0][1].item()
+    safe_prob = probabilities[0][0].item()
+
+    # Adjust probabilities based on rule scores
+    if scam_score > 0:
+        scam_prob = min(scam_prob + (scam_score * 0.1), 0.95)
+        safe_prob = 1 - scam_prob
+    elif safe_score > 0:
+        safe_prob = min(safe_prob + (safe_score * 0.1), 0.95)
+        scam_prob = 1 - safe_prob
+
+    label = "SCAM" if scam_prob > 0.5 else "SAFE"
+
+    if label == "SCAM":
+        risk_level = "HIGH" if scam_prob >= 0.75 else "MEDIUM"
+    else:
+        risk_level = "LOW"
+
+    return {
+        "label": label,
+        "scam_probability": round(scam_prob, 4),
+        "safe_probability": round(safe_prob, 4),
+        "risk_level": risk_level,
+        "signals": matched_signals,
+    }

app/ocr.py

@@ -0,0 +1,76 @@
+import pytesseract
+from PIL import Image, ImageFilter, ImageEnhance
+import io
+import re
+import os
+
+if os.name == 'nt':  # 'nt' = Windows, anything else = Linux/Mac
+    pytesseract.pytesseract.tesseract_cmd = r'C:\Program Files\Tesseract-OCR\tesseract.exe'
+
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg', 'webp', 'bmp'}
+MAX_FILE_SIZE_MB = 10
+
+
+def allowed_file(filename: str) -> bool:
+    return '.' in filename and filename.rsplit('.', 1)[-1].lower() in ALLOWED_EXTENSIONS
+
+
+def preprocess_image(image: Image.Image) -> Image.Image:
+    """Grayscale + sharpen + contrast boost — helps with dark WhatsApp screenshots."""
+    image = image.convert('L')
+    image = image.filter(ImageFilter.SHARPEN)
+    enhancer = ImageEnhance.Contrast(image)
+    return enhancer.enhance(2.0)
+
+
+def clean_ocr_text(raw_text: str) -> str:
+    """Strip blank lines, non-ASCII junk, and collapse whitespace."""
+    lines = [line.strip() for line in raw_text.splitlines() if line.strip()]
+    joined = ' '.join(lines)
+    joined = re.sub(r'[^\x20-\x7E\n]', ' ', joined)
+    return re.sub(r' +', ' ', joined).strip()
+
+
+def extract_text_from_image(file_bytes: bytes) -> dict:
+    """
+    Main entry point. Takes raw image bytes, returns:
+      { 'success': True,  'text': <cleaned str>, 'raw': <raw str> }
+      { 'success': False, 'error': <message> }
+    """
+    # Size check
+    size_mb = len(file_bytes) / (1024 * 1024)
+    if size_mb > MAX_FILE_SIZE_MB:
+        return {'success': False, 'error': f'File too large ({size_mb:.1f} MB). Max is {MAX_FILE_SIZE_MB} MB.'}
+
+    # Open image
+    try:
+        image = Image.open(io.BytesIO(file_bytes))
+    except Exception:
+        return {'success': False, 'error': 'Could not open image. Make sure it is a valid PNG, JPG, or WEBP.'}
+
+    # Resize if very wide (Tesseract slows down on huge images)
+    if image.width > 1600:
+        ratio = 1600 / image.width
+        image = image.resize((1600, int(image.height * ratio)), Image.LANCZOS)
+
+    # Preprocess and OCR
+    try:
+        processed = preprocess_image(image)
+        raw_text = pytesseract.image_to_string(processed, config='--oem 3 --psm 6')
+    except pytesseract.TesseractNotFoundError:
+        return {
+            'success': False,
+            'error': 'Tesseract binary not found. Make sure it is installed and the path is correct in ocr.py.'
+        }
+    except Exception as e:
+        return {'success': False, 'error': f'OCR failed: {str(e)}'}
+
+    cleaned = clean_ocr_text(raw_text)
+
+    if len(cleaned) < 10:
+        return {
+            'success': False,
+            'error': 'No readable text found. Try a clearer, higher-contrast screenshot.'
+        }
+
+    return {'success': True, 'text': cleaned, 'raw': raw_text}

app/pdf_generator.py

@@ -0,0 +1,465 @@
+from reportlab.platypus import (
+    SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle,
+    HRFlowable, KeepTogether
+)
+from reportlab.platypus import BaseDocTemplate, PageTemplate, Frame
+from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
+from reportlab.lib import colors
+from reportlab.lib.units import inch, mm
+from reportlab.lib.enums import TA_LEFT, TA_CENTER, TA_RIGHT
+from reportlab.lib.pagesizes import A4
+from reportlab.pdfgen import canvas
+from datetime import datetime
+import os
+
+# ── Palette ──────────────────────────────────────────────────────────────────
+DARK_BG      = colors.HexColor("#0D1117")
+PANEL_BG     = colors.HexColor("#161B22")
+BORDER_COLOR = colors.HexColor("#30363D")
+ACCENT_CYAN  = colors.HexColor("#22D3EE")
+ACCENT_PINK  = colors.HexColor("#EC4899")
+TEXT_PRIMARY = colors.HexColor("#E6EDF3")
+TEXT_MUTED   = colors.HexColor("#8B949E")
+TEXT_DIM     = colors.HexColor("#484F58")
+
+RISK_HIGH_BG   = colors.HexColor("#3D1515")
+RISK_HIGH_FG   = colors.HexColor("#F87171")
+RISK_HIGH_BAR  = colors.HexColor("#EF4444")
+
+RISK_MED_BG    = colors.HexColor("#2D2008")
+RISK_MED_FG    = colors.HexColor("#FBBF24")
+RISK_MED_BAR   = colors.HexColor("#F59E0B")
+
+RISK_LOW_BG    = colors.HexColor("#0D2818")
+RISK_LOW_FG    = colors.HexColor("#4ADE80")
+RISK_LOW_BAR   = colors.HexColor("#22C55E")
+
+WHITE          = colors.white
+BLACK          = colors.black
+
+
+# ── Page canvas callback (header + footer on every page) ─────────────────────
+def _draw_page(canvas_obj, doc, report_id, timestamp):
+    W, H = A4
+    canvas_obj.saveState()
+
+    # ── Top header bar ────────────────────────────────────────────────────────
+    canvas_obj.setFillColor(DARK_BG)
+    canvas_obj.rect(0, H - 58, W, 58, fill=1, stroke=0)
+
+    # Thin cyan accent line under header
+    canvas_obj.setFillColor(ACCENT_CYAN)
+    canvas_obj.rect(0, H - 60, W, 2, fill=1, stroke=0)
+
+    # Logo / product name
+    canvas_obj.setFillColor(WHITE)
+    canvas_obj.setFont("Helvetica-Bold", 16)
+    canvas_obj.drawString(40, H - 36, "SENTINEL")
+    canvas_obj.setFillColor(ACCENT_CYAN)
+    canvas_obj.setFont("Helvetica-Bold", 16)
+    canvas_obj.drawString(40 + canvas_obj.stringWidth("SENTINEL", "Helvetica-Bold", 16) + 3, H - 36, "AI")
+
+    # Sub-label
+    canvas_obj.setFillColor(TEXT_MUTED)
+    canvas_obj.setFont("Helvetica", 7)
+    canvas_obj.drawString(40, H - 48, "STRUCTURED INTELLIGENCE BRIEF  ·  THREAT ANALYSIS DIVISION")
+
+    # Report ID (right side)
+    canvas_obj.setFillColor(TEXT_MUTED)
+    canvas_obj.setFont("Helvetica", 7)
+    id_text = f"REPORT ID: {report_id}"
+    canvas_obj.drawRightString(W - 40, H - 32, id_text)
+    canvas_obj.drawRightString(W - 40, H - 44, f"GENERATED: {timestamp}")
+
+    # ── Bottom footer bar ─────────────────────────────────────────────────────
+    canvas_obj.setFillColor(DARK_BG)
+    canvas_obj.rect(0, 0, W, 36, fill=1, stroke=0)
+
+    # Thin line above footer
+    canvas_obj.setFillColor(BORDER_COLOR)
+    canvas_obj.rect(0, 36, W, 1, fill=1, stroke=0)
+
+    canvas_obj.setFillColor(TEXT_DIM)
+    canvas_obj.setFont("Helvetica", 7)
+    canvas_obj.drawString(40, 14, "CONFIDENTIAL — FOR AUTHORIZED USE ONLY  ·  SentinelAI © 2026")
+    canvas_obj.drawRightString(W - 40, 14, f"Page {doc.page}")
+
+    canvas_obj.restoreState()
+
+
+# ── Style factory ─────────────────────────────────────────────────────────────
+def _styles():
+    base = getSampleStyleSheet()
+
+    def ps(name, **kw):
+        defaults = dict(fontName="Helvetica", fontSize=9, leading=13,
+                        textColor=TEXT_PRIMARY, spaceAfter=0, spaceBefore=0)
+        defaults.update(kw)
+        return ParagraphStyle(name, **defaults)
+
+    return {
+        "section_label": ps("sl",
+            fontName="Helvetica-Bold", fontSize=7, textColor=ACCENT_CYAN,
+            spaceBefore=18, spaceAfter=4, leading=9,
+        ),
+        "section_rule": ps("sr"),   # placeholder, we use HRFlowable
+        "body": ps("body", fontSize=9, leading=14, textColor=TEXT_PRIMARY),
+        "body_muted": ps("bm", fontSize=8, leading=12, textColor=TEXT_MUTED),
+        "risk_score": ps("rs",
+            fontName="Helvetica-Bold", fontSize=36, leading=40,
+            textColor=WHITE, alignment=TA_CENTER,
+        ),
+        "risk_label": ps("rl",
+            fontName="Helvetica-Bold", fontSize=11, leading=14,
+            textColor=WHITE, alignment=TA_CENTER,
+        ),
+        "risk_sublabel": ps("rsl",
+            fontSize=7, leading=10, textColor=TEXT_MUTED, alignment=TA_CENTER,
+        ),
+        "signal_item": ps("si", fontSize=8, leading=13, textColor=TEXT_PRIMARY,
+                           leftIndent=10),
+        "disclaimer": ps("disc", fontSize=7, leading=10, textColor=TEXT_DIM,
+                          alignment=TA_CENTER),
+        "meta_key": ps("mk", fontName="Helvetica-Bold", fontSize=7,
+                        textColor=TEXT_MUTED, leading=11),
+        "meta_val": ps("mv", fontSize=8, textColor=TEXT_PRIMARY, leading=11),
+        "table_header": ps("th", fontName="Helvetica-Bold", fontSize=7,
+                            textColor=ACCENT_CYAN, leading=10),
+        "table_cell": ps("tc", fontSize=8, textColor=TEXT_PRIMARY, leading=11),
+    }
+
+
+# ── Section header helper ─────────────────────────────────────────────────────
+def _section(title, styles, elements):
+    elements.append(Spacer(1, 4))
+    elements.append(Paragraph(f"▸  {title.upper()}", styles["section_label"]))
+    elements.append(HRFlowable(
+        width="100%", thickness=0.5,
+        color=BORDER_COLOR, spaceAfter=8, spaceBefore=2
+    ))
+
+
+# ── Dark panel table helper ───────────────────────────────────────────────────
+def _panel(inner_elements, bg=None, border=BORDER_COLOR, padding=10):
+    """Wraps content in a dark-background rounded-ish table cell."""
+    bg = bg or PANEL_BG
+    t = Table([[inner_elements]], colWidths=["100%"])
+    t.setStyle(TableStyle([
+        ("BACKGROUND",  (0, 0), (-1, -1), bg),
+        ("BOX",         (0, 0), (-1, -1), 0.5, border),
+        ("TOPPADDING",  (0, 0), (-1, -1), padding),
+        ("BOTTOMPADDING",(0,0), (-1, -1), padding),
+        ("LEFTPADDING", (0, 0), (-1, -1), padding),
+        ("RIGHTPADDING",(0, 0), (-1, -1), padding),
+    ]))
+    return t
+
+
+# ── Main generator ────────────────────────────────────────────────────────────
+def generate_pdf(data, filepath):
+    W, H = A4
+    timestamp = datetime.now().strftime("%d %B %Y  %H:%M UTC+5:30")
+    report_id = datetime.now().strftime("SIB-%Y%m%d-%H%M%S")
+
+    # Margins: leave room for header (58+2=60) and footer (36+1=37)
+    doc = SimpleDocTemplate(
+        filepath,
+        pagesize=A4,
+        leftMargin=40,
+        rightMargin=40,
+        topMargin=75,
+        bottomMargin=50,
+    )
+
+    styles = _styles()
+    elements = []
+
+    # ── 1. CLASSIFICATION BANNER ──────────────────────────────────────────────
+    banner = Table(
+        [[ Paragraph("⬛  THREAT INTELLIGENCE REPORT  —  CONFIDENTIAL", ParagraphStyle(
+            "banner", fontName="Helvetica-Bold", fontSize=8,
+            textColor=ACCENT_CYAN, alignment=TA_CENTER, leading=10
+        )) ]],
+        colWidths=[W - 80]
+    )
+    banner.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), DARK_BG),
+        ("BOX",          (0,0),(-1,-1), 1, ACCENT_CYAN),
+        ("TOPPADDING",   (0,0),(-1,-1), 6),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 6),
+    ]))
+    elements.append(banner)
+    elements.append(Spacer(1, 14))
+
+    # ── 2. METADATA ROW ───────────────────────────────────────────────────────
+    meta_rows = [
+        [
+            Paragraph("CLASSIFICATION", styles["meta_key"]),
+            Paragraph("REPORT TYPE", styles["meta_key"]),
+            Paragraph("ANALYSIS ENGINE", styles["meta_key"]),
+            Paragraph("TIMESTAMP", styles["meta_key"]),
+        ],
+        [
+            Paragraph("RESTRICTED", styles["meta_val"]),
+            Paragraph("Digital Threat Assessment", styles["meta_val"]),
+            Paragraph("SentinelAI v2 · Transformer NLP", styles["meta_val"]),
+            Paragraph(timestamp, styles["meta_val"]),
+        ],
+    ]
+    meta_table = Table(meta_rows, colWidths=[(W - 80) / 4] * 4)
+    meta_table.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), PANEL_BG),
+        ("BOX",          (0,0),(-1,-1), 0.5, BORDER_COLOR),
+        ("LINEBELOW",    (0,0),(-1,0),  0.5, BORDER_COLOR),
+        ("LINEBEFORE",   (1,0),(3,-1),  0.5, BORDER_COLOR),
+        ("TOPPADDING",   (0,0),(-1,-1), 7),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 7),
+        ("LEFTPADDING",  (0,0),(-1,-1), 10),
+        ("RIGHTPADDING", (0,0),(-1,-1), 10),
+    ]))
+    elements.append(meta_table)
+    elements.append(Spacer(1, 18))
+
+    # ── 3. RISK ASSESSMENT PANEL ──────────────────────────────────────────────
+    risk_level = data.get("risk_level", "LOW")
+    risk_score = float(data.get("risk_score", 0))
+
+    if risk_level == "HIGH":
+        risk_bg, risk_fg, risk_bar = RISK_HIGH_BG, RISK_HIGH_FG, RISK_HIGH_BAR
+        risk_label_text = "HIGH RISK  —  SCAM DETECTED"
+        risk_desc = "This message exhibits strong indicators of a digital arrest or financial scam. Immediate action is advised."
+        threat_icon = "🔴"
+    elif risk_level == "MEDIUM":
+        risk_bg, risk_fg, risk_bar = RISK_MED_BG, RISK_MED_FG, RISK_MED_BAR
+        risk_label_text = "MEDIUM RISK  —  SUSPICIOUS"
+        risk_desc = "This message contains several suspicious patterns. Exercise caution and verify through official channels."
+        threat_icon = "🟡"
+    else:
+        risk_bg, risk_fg, risk_bar = RISK_LOW_BG, RISK_LOW_FG, RISK_LOW_BAR
+        risk_label_text = "LOW RISK  —  LIKELY SAFE"
+        risk_desc = "No significant scam indicators detected. The message appears to be legitimate communication."
+        threat_icon = "🟢"
+
+    score_style = ParagraphStyle("score_dyn", fontName="Helvetica-Bold",
+                                  fontSize=42, leading=48, textColor=risk_fg,
+                                  alignment=TA_CENTER)
+    label_style = ParagraphStyle("label_dyn", fontName="Helvetica-Bold",
+                                  fontSize=10, leading=14, textColor=risk_fg,
+                                  alignment=TA_CENTER)
+    desc_style  = ParagraphStyle("desc_dyn", fontSize=8, leading=12,
+                                  textColor=TEXT_MUTED, alignment=TA_CENTER)
+
+    # Progress bar simulation via a two-cell table
+    bar_filled = max(2, int((risk_score / 100) * 100))
+    bar_empty  = 100 - bar_filled
+    bar_table  = Table(
+        [["", ""]],
+        colWidths=[((W - 80 - 40) * bar_filled / 100),
+                   ((W - 80 - 40) * bar_empty  / 100)]
+    )
+    bar_table.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(0,0), risk_bar),
+        ("BACKGROUND",   (1,0),(1,0), BORDER_COLOR),
+        ("TOPPADDING",   (0,0),(-1,-1), 3),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 3),
+        ("LEFTPADDING",  (0,0),(-1,-1), 0),
+        ("RIGHTPADDING", (0,0),(-1,-1), 0),
+    ]))
+
+    risk_inner = [
+        Paragraph(f"{threat_icon}  {risk_label_text}", label_style),
+        Spacer(1, 6),
+        Paragraph(f"{risk_score:.1f}%", score_style),
+        Spacer(1, 8),
+        bar_table,
+        Spacer(1, 8),
+        Paragraph(risk_desc, desc_style),
+    ]
+
+    risk_panel = Table([[risk_inner]], colWidths=[W - 80])
+    risk_panel.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), risk_bg),
+        ("BOX",          (0,0),(-1,-1), 1, risk_bar),
+        ("TOPPADDING",   (0,0),(-1,-1), 16),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 16),
+        ("LEFTPADDING",  (0,0),(-1,-1), 20),
+        ("RIGHTPADDING", (0,0),(-1,-1), 20),
+    ]))
+    elements.append(risk_panel)
+    elements.append(Spacer(1, 18))
+
+    # ── 4. ANALYZED MESSAGE ───────────────────────────────────────────────────
+    _section("01  ·  Intercepted Communication", styles, elements)
+
+    msg_text = data.get("message", "No message provided.")
+    msg_para = Paragraph(msg_text, ParagraphStyle(
+        "msg", fontSize=9, leading=15, textColor=TEXT_PRIMARY,
+        fontName="Courier", leftIndent=0
+    ))
+    msg_panel = Table([[msg_para]], colWidths=[W - 80])
+    msg_panel.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), PANEL_BG),
+        ("LINEAFTER",    (0,0),(0,-1),  3, ACCENT_CYAN),   # left accent bar
+        ("BOX",          (0,0),(-1,-1), 0.5, BORDER_COLOR),
+        ("TOPPADDING",   (0,0),(-1,-1), 12),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 12),
+        ("LEFTPADDING",  (0,0),(-1,-1), 14),
+        ("RIGHTPADDING", (0,0),(-1,-1), 14),
+    ]))
+    elements.append(msg_panel)
+    elements.append(Spacer(1, 14))
+
+    # ── 5. DETECTED SIGNALS ───────────────────────────────────────────────────
+    _section("02  ·  Detected Risk Indicators", styles, elements)
+
+    signals = data.get("signals", [])
+    if signals:
+        signal_rows = []
+        for i, sig in enumerate(signals, 1):
+            signal_rows.append([
+                Paragraph(f"{i:02d}", ParagraphStyle(
+                    "snum", fontName="Helvetica-Bold", fontSize=8,
+                    textColor=ACCENT_CYAN, alignment=TA_CENTER, leading=12
+                )),
+                Paragraph(f"⚠  {sig}", ParagraphStyle(
+                    "stxt", fontSize=8, leading=13, textColor=TEXT_PRIMARY
+                )),
+            ])
+
+        sig_table = Table(signal_rows, colWidths=[30, W - 80 - 30])
+        sig_table.setStyle(TableStyle([
+            ("BACKGROUND",   (0,0),(-1,-1), PANEL_BG),
+            ("BOX",          (0,0),(-1,-1), 0.5, BORDER_COLOR),
+            ("LINEBELOW",    (0,0),(-1,-2), 0.3, BORDER_COLOR),
+            ("VALIGN",       (0,0),(-1,-1), "MIDDLE"),
+            ("TOPPADDING",   (0,0),(-1,-1), 7),
+            ("BOTTOMPADDING",(0,0),(-1,-1), 7),
+            ("LEFTPADDING",  (0,0),(-1,-1), 10),
+            ("RIGHTPADDING", (0,0),(-1,-1), 10),
+            ("BACKGROUND",   (0,0),(0,-1), colors.HexColor("#0D1F2D")),
+        ]))
+        elements.append(sig_table)
+    else:
+        no_sig = Table(
+            [[Paragraph("✔  No high-confidence scam indicators detected in this message.", ParagraphStyle(
+                "nosig", fontSize=8, leading=12, textColor=RISK_LOW_FG
+            ))]],
+            colWidths=[W - 80]
+        )
+        no_sig.setStyle(TableStyle([
+            ("BACKGROUND",   (0,0),(-1,-1), RISK_LOW_BG),
+            ("BOX",          (0,0),(-1,-1), 0.5, RISK_LOW_BAR),
+            ("TOPPADDING",   (0,0),(-1,-1), 10),
+            ("BOTTOMPADDING",(0,0),(-1,-1), 10),
+            ("LEFTPADDING",  (0,0),(-1,-1), 14),
+            ("RIGHTPADDING", (0,0),(-1,-1), 14),
+        ]))
+        elements.append(no_sig)
+
+    elements.append(Spacer(1, 14))
+
+    # ── 6. AI INTERPRETATION ──────────────────────────────────────────────────
+    _section("03  ·  AI Model Interpretation", styles, elements)
+
+    interp_rows = [
+        ["Model Architecture", "Fine-tuned Transformer (BERT-class) · Digital Scam Corpus"],
+        ["Detection Method",   "Linguistic pattern matching + structural scam framework analysis"],
+        ["Confidence Basis",   f"{max(risk_score, 100 - risk_score):.1f}% model confidence on primary classification"],
+        ["Threat Category",    "Digital Arrest Scam / Impersonation / Financial Coercion"],
+    ]
+    interp_table = Table(
+        [[Paragraph(k, styles["meta_key"]), Paragraph(v, styles["table_cell"])]
+         for k, v in interp_rows],
+        colWidths=[130, W - 80 - 130]
+    )
+    interp_table.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), PANEL_BG),
+        ("BACKGROUND",   (0,0),(0,-1),  colors.HexColor("#0D1F2D")),
+        ("BOX",          (0,0),(-1,-1), 0.5, BORDER_COLOR),
+        ("LINEBELOW",    (0,0),(-1,-2), 0.3, BORDER_COLOR),
+        ("LINEAFTER",    (0,0),(0,-1),  0.5, BORDER_COLOR),
+        ("VALIGN",       (0,0),(-1,-1), "MIDDLE"),
+        ("TOPPADDING",   (0,0),(-1,-1), 7),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 7),
+        ("LEFTPADDING",  (0,0),(-1,-1), 10),
+        ("RIGHTPADDING", (0,0),(-1,-1), 10),
+    ]))
+    elements.append(interp_table)
+    elements.append(Spacer(1, 14))
+
+    # ── 7. RECOMMENDED ACTIONS ────────────────────────────────────────────────
+    _section("04  ·  Recommended Immediate Actions", styles, elements)
+
+    actions = [
+        ("CRITICAL", "Do NOT transfer funds, share OTP, passwords, or any personal credentials."),
+        ("CRITICAL", "Disconnect immediately from the suspicious communication channel."),
+        ("HIGH",     "Verify the sender's identity through official government or bank websites only."),
+        ("HIGH",     "Report the incident to the National Cybercrime Portal: cybercrime.gov.in"),
+        ("MEDIUM",   "Preserve all evidence — screenshots, call logs, and message history."),
+        ("MEDIUM",   "Alert family members and close contacts about this threat pattern."),
+    ]
+
+    priority_colors = {
+        "CRITICAL": (colors.HexColor("#3D1515"), RISK_HIGH_FG),
+        "HIGH":     (colors.HexColor("#2D2008"), RISK_MED_FG),
+        "MEDIUM":   (colors.HexColor("#0D2818"), RISK_LOW_FG),
+    }
+
+    action_data = []
+    for priority, text in actions:
+        bg, fg = priority_colors[priority]
+        action_data.append([
+            Paragraph(priority, ParagraphStyle(
+                "pri", fontName="Helvetica-Bold", fontSize=6,
+                textColor=fg, alignment=TA_CENTER, leading=9
+            )),
+            Paragraph(text, ParagraphStyle(
+                "act", fontSize=8, leading=13, textColor=TEXT_PRIMARY
+            )),
+        ])
+
+    action_table = Table(action_data, colWidths=[55, W - 80 - 55])
+    action_table.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), PANEL_BG),
+        ("BOX",          (0,0),(-1,-1), 0.5, BORDER_COLOR),
+        ("LINEBELOW",    (0,0),(-1,-2), 0.3, BORDER_COLOR),
+        ("LINEAFTER",    (0,0),(0,-1),  0.5, BORDER_COLOR),
+        ("VALIGN",       (0,0),(-1,-1), "MIDDLE"),
+        ("TOPPADDING",   (0,0),(-1,-1), 7),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 7),
+        ("LEFTPADDING",  (0,0),(-1,-1), 8),
+        ("RIGHTPADDING", (0,0),(-1,-1), 8),
+        # Per-row background for priority column
+        ("BACKGROUND",   (0,0),(0,1),  colors.HexColor("#3D1515")),
+        ("BACKGROUND",   (0,2),(0,3),  colors.HexColor("#2D2008")),
+        ("BACKGROUND",   (0,4),(0,5),  colors.HexColor("#0D2818")),
+    ]))
+    elements.append(action_table)
+    elements.append(Spacer(1, 20))
+
+    # ── 8. DISCLAIMER ─────────────────────────────────────────────────────────
+    disc_table = Table(
+        [[Paragraph(
+            "DISCLAIMER  ·  SentinelAI provides AI-based probabilistic risk estimation and does not constitute "
+            "legal advice. All findings are based on pattern recognition and should be verified through official "
+            "law enforcement or financial authorities. This report is generated for informational purposes only.",
+            styles["disclaimer"]
+        )]],
+        colWidths=[W - 80]
+    )
+    disc_table.setStyle(TableStyle([
+        ("BACKGROUND",   (0,0),(-1,-1), DARK_BG),
+        ("BOX",          (0,0),(-1,-1), 0.5, BORDER_COLOR),
+        ("TOPPADDING",   (0,0),(-1,-1), 10),
+        ("BOTTOMPADDING",(0,0),(-1,-1), 10),
+        ("LEFTPADDING",  (0,0),(-1,-1), 14),
+        ("RIGHTPADDING", (0,0),(-1,-1), 14),
+    ]))
+    elements.append(disc_table)
+
+    # ── Build ─────────────────────────────────────────────────────────────────
+    doc.build(
+        elements,
+        onFirstPage=lambda c, d: _draw_page(c, d, report_id, timestamp),
+        onLaterPages=lambda c, d: _draw_page(c, d, report_id, timestamp),
+    )

app/templates/index.html

@@ -0,0 +1,1060 @@
+<!DOCTYPE html>
+<html class="dark" lang="en">
+<head>
+<meta charset="utf-8"/>
+<meta content="width=device-width, initial-scale=1.0" name="viewport"/>
+<title>SENTINELAI — Threat Analysis Engine</title>
+<meta name="description" content="SentinelAI: AI-powered threat analysis engine for detecting digital arrest scams, phishing, and social engineering attacks."/>
+<script src="https://cdn.tailwindcss.com?plugins=forms,container-queries"></script>
+<link href="https://fonts.googleapis.com/css2?family=Inter:wght@100;300;400;500;600;700;800&family=JetBrains+Mono:wght@300;400;500;700&display=swap" rel="stylesheet"/>
+<link href="https://fonts.googleapis.com/css2?family=Material+Symbols+Outlined:wght,FILL@100..700,0..1&display=swap" rel="stylesheet"/>
+<script id="tailwind-config">
+  tailwind.config = {
+    darkMode: "class",
+    theme: {
+      extend: {
+        colors: {
+          "background": "#11131e",
+          "inverse-primary": "#5646d7",
+          "tertiary": "#ffb3b4",
+          "on-error-container": "#ffdad6",
+          "secondary-fixed-dim": "#00e478",
+          "on-surface": "#e1e1f2",
+          "secondary-container": "#00e779",
+          "inverse-surface": "#e1e1f2",
+          "primary": "#c5c0ff",
+          "surface-tint": "#c5c0ff",
+          "primary-fixed-dim": "#c5c0ff",
+          "tertiary-fixed-dim": "#ffb3b4",
+          "surface-variant": "#323440",
+          "on-error": "#690005",
+          "surface-container-lowest": "#0c0e18",
+          "secondary": "#7cffa3",
+          "on-tertiary-container": "#5b0012",
+          "outline": "#928fa0",
+          "on-tertiary-fixed": "#40000a",
+          "on-background": "#e1e1f2",
+          "on-primary-fixed-variant": "#3d28bf",
+          "secondary-fixed": "#61ff98",
+          "tertiary-fixed": "#ffdad9",
+          "on-secondary-fixed-variant": "#005227",
+          "primary-fixed": "#e4dfff",
+          "surface": "#11131e",
+          "surface-container-high": "#272935",
+          "surface-container": "#1d1f2b",
+          "on-primary-fixed": "#150067",
+          "primary-container": "#8b80ff",
+          "on-primary": "#2600a1",
+          "on-tertiary": "#680016",
+          "error": "#ffb4ab",
+          "on-surface-variant": "#c8c4d7",
+          "outline-variant": "#474554",
+          "surface-container-highest": "#323440",
+          "surface-container-low": "#191b26",
+          "on-tertiary-fixed-variant": "#920023",
+          "surface-dim": "#11131e",
+          "tertiary-container": "#ff5262",
+          "on-secondary-container": "#006230",
+          "inverse-on-surface": "#2e303c",
+          "on-secondary": "#003919",
+          "on-primary-container": "#20008e",
+          "on-secondary-fixed": "#00210c",
+          "error-container": "#93000a",
+          "surface-bright": "#373845"
+        },
+        fontFamily: {
+          "headline": ["Inter"],
+          "body": ["Inter"],
+          "label": ["Inter"],
+          "mono": ["JetBrains Mono"]
+        },
+        borderRadius: {"DEFAULT": "0.25rem", "lg": "0.5rem", "xl": "0.75rem", "full": "9999px"},
+      },
+    },
+  }
+</script>
+<style>
+    body {
+        background-color: #0D0F1A;
+        background-image: radial-gradient(circle at center, #0D0F1A 0%, #07080F 100%),
+                          radial-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 1px);
+        background-size: 100% 100%, 24px 24px;
+        color: #E1E1F2;
+    }
+    .dot-grid {
+        background-image: radial-gradient(rgba(255, 255, 255, 0.03) 1px, transparent 0);
+        background-size: 24px 24px;
+    }
+    .material-symbols-outlined {
+        font-variation-settings: 'FILL' 0, 'wght' 300, 'GRAD' 0, 'opsz' 24;
+    }
+    .glass-panel {
+        background: rgba(29, 31, 43, 0.8);
+        backdrop-filter: blur(12px);
+    }
+    .glow-red {
+        box-shadow: 0 0 60px rgba(255, 82, 98, 0.12);
+    }
+    .safe-glow {
+        box-shadow: 0 0 60px rgba(0, 231, 121, 0.08);
+    }
+
+    /* Smooth view transitions */
+    .view-transition {
+        transition: opacity 0.4s ease, transform 0.4s ease;
+    }
+    .view-hidden {
+        opacity: 0;
+        transform: translateY(12px);
+        pointer-events: none;
+        position: absolute;
+        top: 0; left: 0; right: 0;
+    }
+    .view-visible {
+        opacity: 1;
+        transform: translateY(0);
+        pointer-events: auto;
+        position: relative;
+    }
+
+    /* Processing pulse */
+    @keyframes pulse-ring {
+        0% { transform: scale(0.8); opacity: 0.6; }
+        50% { transform: scale(1.1); opacity: 0.2; }
+        100% { transform: scale(0.8); opacity: 0.6; }
+    }
+    .pulse-ring {
+        animation: pulse-ring 2s ease-in-out infinite;
+    }
+
+    /* Scanning line */
+    @keyframes scan-line {
+        0% { top: 0; opacity: 0; }
+        10% { opacity: 1; }
+        90% { opacity: 1; }
+        100% { top: 100%; opacity: 0; }
+    }
+    .scan-line {
+        animation: scan-line 2s ease-in-out infinite;
+    }
+
+    /* ── OCR Drop Zone ───────────────────────────────── */
+    #dropZone {
+        transition: border-color 0.25s ease, background-color 0.25s ease;
+    }
+    #dropZone.drag-over {
+        border-color: rgba(124, 111, 255, 0.5) !important;
+        background-color: rgba(124, 111, 255, 0.04);
+    }
+
+    /* ── Mode toggle pill transitions ────────────────── */
+    .mode-pill {
+        transition: background-color 0.2s ease, color 0.2s ease, border-color 0.2s ease;
+    }
+
+    /* ── OCR preview scrollbar ───────────────────────── */
+    #ocrPreviewText::-webkit-scrollbar { width: 3px; }
+    #ocrPreviewText::-webkit-scrollbar-track { background: transparent; }
+    #ocrPreviewText::-webkit-scrollbar-thumb { background: rgba(124,111,255,0.2); border-radius: 999px; }
+</style>
+</head>
+<body class="font-body text-on-surface min-h-screen selection:bg-primary/30">
+<!-- Background Layer -->
+<div class="fixed inset-0 dot-grid pointer-events-none"></div>
+
+<!-- ============================================================ -->
+<!-- VIEW: IDLE STATE                                             -->
+<!-- ============================================================ -->
+<div id="viewIdle" class="view-transition view-visible">
+<main class="relative z-10 flex items-center justify-center min-h-screen p-6">
+<div class="w-full max-w-[1100px] grid grid-cols-1 md:grid-cols-2 bg-surface-container-low/40 backdrop-blur-md rounded-xl overflow-hidden shadow-[0_20px_80px_rgba(0,0,0,0.45)] outline outline-1 outline-white/5">
+
+  <!-- Left Panel: Input -->
+  <section class="p-12 flex flex-col justify-between border-r border-outline-variant/10">
+    <div class="space-y-12">
+      <header>
+        <div class="flex items-baseline gap-2">
+          <h1 class="text-[22px] font-light tracking-[0.12em] text-white leading-none">SENTINEL<span class="text-[#7C6FFF] text-[11px] font-semibold tracking-normal align-top leading-none ml-1">AI</span></h1>
+        </div>
+        <p class="text-[9px] text-[#4E5A6E] tracking-[0.05em] font-mono mt-1 uppercase">THREAT ANALYSIS ENGINE</p>
+      </header>
+
+      <div class="space-y-4">
+
+        <!-- Label + Mode Toggle Row -->
+        <div class="flex items-center justify-between">
+          <label class="block text-[10px] text-[#4E5A6E] tracking-[0.15em] font-semibold uppercase">FORENSIC INPUT</label>
+
+          <!-- Mode Toggle Pills -->
+          <div class="flex items-center gap-0.5 p-0.5 bg-[#090C12] border border-white/5 rounded-lg">
+            <button
+              id="btnTextMode"
+              onclick="switchMode('text')"
+              class="mode-pill flex items-center gap-1.5 px-3 py-1.5 rounded-md
+                     bg-[#7C6FFF]/15 text-[#7C6FFF] border border-[#7C6FFF]/20
+                     text-[9px] font-mono tracking-widest uppercase font-semibold"
+            >
+              <span class="material-symbols-outlined text-[11px]">text_fields</span>
+              TEXT
+            </button>
+            <button
+              id="btnImageMode"
+              onclick="switchMode('image')"
+              class="mode-pill flex items-center gap-1.5 px-3 py-1.5 rounded-md
+                     bg-transparent text-[#4E5A6E] border border-transparent
+                     text-[9px] font-mono tracking-widest uppercase font-semibold
+                     hover:text-[#7C6FFF]/60"
+            >
+              <span class="material-symbols-outlined text-[11px]">screenshot_monitor</span>
+              SCREENSHOT
+            </button>
+          </div>
+        </div>
+
+        <!-- ── TEXT ZONE ─────────────────────────────── -->
+        <div id="textZone" class="relative group">
+          <textarea id="messageInput"
+            class="w-full h-64 bg-[#090C12] border border-white/10 rounded-xl p-5 text-on-surface font-mono text-sm
+                   focus:ring-1 focus:ring-primary/40 focus:border-primary/40 outline-none transition-all
+                   placeholder:text-[#2E3A4E] resize-none"
+            placeholder="Paste any suspicious message, URL, or code snippet for immediate neural evaluation..."
+          ></textarea>
+          <div class="absolute bottom-4 right-4 flex gap-2">
+            <span class="bg-surface-container text-[9px] font-mono px-2 py-1 rounded text-outline border border-outline-variant/20">UTF-8</span>
+            <span class="bg-surface-container text-[9px] font-mono px-2 py-1 rounded text-outline border border-outline-variant/20">RAW</span>
+          </div>
+        </div>
+
+        <!-- ── IMAGE ZONE ─────────────────────────────── -->
+        <div id="imageZone" class="space-y-3" style="display:none;">
+
+          <!-- Drop Zone — matches textarea dimensions and style -->
+          <div
+            id="dropZone"
+            class="relative w-full h-64 bg-[#090C12] border border-dashed border-white/10 rounded-xl
+                   flex flex-col items-center justify-center gap-3 cursor-pointer overflow-hidden group"
+            onclick="document.getElementById('imgInput').click()"
+            ondragover="handleDragOver(event)"
+            ondragleave="handleDragLeave(event)"
+            ondrop="handleDrop(event)"
+          >
+            <!-- Idle placeholder -->
+            <div id="dropPlaceholder" class="flex flex-col items-center gap-3 pointer-events-none">
+              <span class="material-symbols-outlined text-[#2E3A4E] text-[42px] group-hover:text-[#7C6FFF]/30 transition-colors duration-300"
+                    style="font-variation-settings:'FILL' 0,'wght' 200,'GRAD' 0,'opsz' 48;">screenshot_monitor</span>
+              <div class="text-center">
+                <p class="text-[11px] text-[#4E5A6E] tracking-[0.12em] font-semibold uppercase">Drop screenshot here</p>
+                <p class="text-[9px] text-[#2E3A4E] font-mono mt-1">or click to browse · PNG · JPG · WEBP · max 10 MB</p>
+              </div>
+            </div>
+
+            <!-- Image preview (hidden until file selected) -->
+            <img
+              id="imgPreview"
+              src="" alt="Screenshot preview"
+              class="hidden absolute inset-0 w-full h-full object-contain p-3"
+            />
+
+            <!-- Overlay badge on top of preview -->
+            <div id="imgOverlay" class="hidden absolute bottom-0 inset-x-0 bg-gradient-to-t from-[#090C12]/90 to-transparent px-4 py-3 flex items-center gap-2">
+              <span class="material-symbols-outlined text-[#7C6FFF] text-[14px]">check_circle</span>
+              <p id="imgFilename" class="text-[9px] font-mono text-[#7C6FFF] truncate max-w-[200px]"></p>
+              <span class="text-[8px] text-[#4E5A6E] ml-auto">click to change</span>
+            </div>
+
+            <input type="file" id="imgInput" accept="image/*" class="hidden" onchange="handleFileSelect(event)"/>
+          </div>
+
+          <!-- OCR Extracted Text Preview — appears after analysis -->
+          <div id="ocrPreviewBox" class="hidden">
+            <div class="flex items-center gap-2 mb-1.5">
+              <span class="text-[8px] text-[#4E5A6E] tracking-[0.12em] font-mono uppercase">Extracted Text</span>
+              <div class="flex-1 h-[1px] bg-white/5"></div>
+              <span class="text-[8px] font-mono text-[#7C6FFF]/60">OCR OUTPUT</span>
+            </div>
+            <div
+              id="ocrPreviewText"
+              class="text-[10px] font-mono text-on-surface-variant bg-[#090C12] border border-white/5
+                     rounded-lg p-3 max-h-16 overflow-y-auto whitespace-pre-wrap leading-relaxed"
+            ></div>
+          </div>
+
+        </div>
+        <!-- ── END IMAGE ZONE ─────────────────────────── -->
+
+        <button id="analyzeBtn"
+          class="w-full py-4 px-6 bg-gradient-to-r from-[#7C6FFF] to-[#5B8DEF] text-on-primary
+                 font-bold text-sm tracking-widest rounded-xl transition-all hover:scale-[1.01]
+                 active:scale-95 shadow-[0_4px_20px_rgba(124,111,255,0.3)]">
+          RUN ANALYSIS
+        </button>
+
+      </div>
+    </div>
+
+    <footer class="mt-12">
+      <div class="flex items-center gap-2">
+        <span id="statusDot" class="w-2 h-2 rounded-full bg-secondary shadow-[0_0_10px_rgba(124,255,163,0.3)]"></span>
+        <p class="text-[10px] text-[#2E3A4E] font-mono tracking-tighter uppercase">Powered by DistilBERT · Hybrid Inference · v2.4.0-Stable</p>
+      </div>
+    </footer>
+  </section>
+
+  <!-- Right Panel: Atmospheric HUD -->
+  <section class="p-12 flex flex-col items-center justify-center relative overflow-hidden bg-surface-container-lowest/50">
+    <!-- Idle Reticle -->
+    <div id="hudIdle" class="relative w-80 h-80 flex items-center justify-center">
+      <div class="absolute inset-0 rounded-full border border-[#7C6FFF]/10"></div>
+      <div class="absolute inset-4 rounded-full border border-[#7C6FFF]/5"></div>
+      <div class="absolute inset-16 rounded-full border border-[#7C6FFF]/5"></div>
+      <!-- Tactical Notches -->
+      <div class="absolute inset-0 flex justify-center py-2"><div class="w-[1px] h-2 bg-[#7C6FFF]/20"></div></div>
+      <div class="absolute inset-0 flex justify-center items-end py-2"><div class="w-[1px] h-2 bg-[#7C6FFF]/20"></div></div>
+      <div class="absolute inset-0 flex items-center px-2"><div class="w-2 h-[1px] bg-[#7C6FFF]/20"></div></div>
+      <div class="absolute inset-0 flex items-center justify-end px-2"><div class="w-2 h-[1px] bg-[#7C6FFF]/20"></div></div>
+      <!-- Center Dot -->
+      <div class="w-1 h-1 rounded-full bg-[#7C6FFF]/40 shadow-[0_0_15px_rgba(124,111,255,0.4)]"></div>
+      <!-- HUD Text -->
+      <div id="hudStatusText" class="absolute bottom-8 left-1/2 -translate-x-1/2 flex flex-col items-center gap-2">
+        <span class="text-[10px] text-[#2E3A4E] tracking-[0.15em] font-semibold uppercase">AWAITING ANALYSIS</span>
+        <div class="flex gap-1">
+          <span class="w-1 h-1 bg-[#2E3A4E] rounded-full"></span>
+          <span class="w-1 h-1 bg-[#2E3A4E]/50 rounded-full"></span>
+          <span class="w-1 h-1 bg-[#2E3A4E]/20 rounded-full"></span>
+        </div>
+      </div>
+      <!-- Ghost Data Points -->
+      <div class="absolute top-10 right-10 flex flex-col items-end gap-1 opacity-20">
+        <span class="text-[8px] font-mono text-[#7C6FFF]">X: 42.190</span>
+        <span class="text-[8px] font-mono text-[#7C6FFF]">Y: 09.441</span>
+      </div>
+      <div class="absolute bottom-10 left-10 opacity-20">
+        <span id="scannerModeLabel" class="text-[8px] font-mono text-[#7C6FFF]">SCANNER_IDLE_MODE</span>
+      </div>
+    </div>
+    <!-- Ambient Glow Behind Reticle -->
+    <div class="absolute top-1/2 left-1/2 -translate-x-1/2 -translate-y-1/2 w-96 h-96 bg-primary/5 blur-[120px] rounded-full pointer-events-none"></div>
+  </section>
+
+</div>
+</main>
+
+<!-- Side Decorations -->
+<div class="fixed left-6 top-1/2 -translate-y-1/2 flex flex-col gap-8 opacity-40">
+  <div class="h-32 w-[1px] bg-gradient-to-b from-transparent via-outline-variant/30 to-transparent"></div>
+  <div class="flex flex-col gap-4">
+    <span class="text-[8px] font-mono -rotate-90 text-[#4E5A6E] uppercase">Security_Protocol_Active</span>
+    <span class="text-[8px] font-mono -rotate-90 text-[#4E5A6E] uppercase">Neural_Link_Stable</span>
+  </div>
+</div>
+<div class="fixed right-8 top-1/2 -translate-y-1/2 flex flex-col gap-12 text-right opacity-30">
+  <div class="space-y-1">
+    <p class="text-[9px] font-mono text-outline-variant uppercase">Latency</p>
+    <p id="metricLatency" class="text-xs font-mono text-on-surface-variant">12ms</p>
+  </div>
+  <div class="space-y-1">
+    <p class="text-[9px] font-mono text-outline-variant uppercase">Throughput</p>
+    <p class="text-xs font-mono text-on-surface-variant">4.2GB/s</p>
+  </div>
+  <div class="space-y-1">
+    <p class="text-[9px] font-mono text-outline-variant uppercase">Entropy</p>
+    <p id="metricEntropy" class="text-xs font-mono text-on-surface-variant">0.02</p>
+  </div>
+</div>
+</div>
+
+<!-- ============================================================ -->
+<!-- VIEW: RESULT STATE (High Risk / Safe - dynamically styled)   -->
+<!-- ============================================================ -->
+<div id="viewResult" class="view-transition view-hidden">
+<main class="max-w-[1100px] mx-auto pt-16 px-8 pb-20 relative z-10">
+  <!-- Dashboard Header -->
+  <div class="flex flex-col md:flex-row justify-between items-start md:items-end mb-12 gap-6">
+    <div>
+      <div class="flex items-center gap-3 mb-2">
+        <span id="resultIncidentBadge" class="font-mono text-[10px] tracking-widest uppercase px-2 py-0.5 border rounded">Incident #---</span>
+        <span class="w-1 h-1 bg-outline-variant rounded-full"></span>
+        <span class="font-mono text-[10px] tracking-widest text-on-surface-variant uppercase">CRITICAL PRIORITY</span>
+      </div>
+      <h1 class="text-4xl font-light tracking-tight text-white leading-tight">Analysis Result: <span id="resultHeadline" class="font-semibold"></span></h1>
+    </div>
+    <div class="flex gap-3">
+      <div class="px-3 py-1.5 bg-surface-container-low border border-outline-variant/10 rounded font-mono text-[9px] text-on-surface-variant uppercase tracking-widest">ENGINE: SENTINELAI v2</div>
+      <!-- Input Method Badge — updates dynamically -->
+      <div id="resultInputBadge" class="px-3 py-1.5 bg-surface-container-low border border-outline-variant/10 rounded font-mono text-[9px] text-on-surface-variant uppercase tracking-widest">HYBRID INFERENCE MODE</div>
+    </div>
+  </div>
+
+  <!-- Main Content -->
+  <div class="grid grid-cols-1 lg:grid-cols-12 gap-8 items-start">
+
+    <!-- Left Panel: Input Source (readonly) -->
+    <div class="lg:col-span-5 flex flex-col gap-6">
+      <div class="glass-panel p-1 rounded-xl border border-outline-variant/10 bg-surface-container-lowest overflow-hidden shadow-2xl">
+        <div class="px-4 py-3 bg-surface-container-low/50 flex items-center justify-between border-b border-outline-variant/5">
+          <span id="resultSourceLabel" class="font-mono text-[10px] uppercase tracking-tighter text-on-surface-variant">Source Content (SMS/Text)</span>
+          <span class="material-symbols-outlined text-[14px] text-on-surface-variant">content_paste</span>
+        </div>
+        <textarea id="resultMessageDisplay"
+          class="w-full bg-transparent border-none focus:ring-0 text-on-surface/90 font-mono text-sm leading-relaxed p-6 h-[400px] resize-none overflow-y-auto"
+          readonly></textarea>
+      </div>
+      <!-- Tactical Indicator Bar -->
+      <div id="resultRecommendation" class="flex flex-col gap-2 p-4 rounded-r-lg">
+        <div id="resultRecommendationLabel" class="text-[10px] font-bold tracking-widest uppercase">System Recommendation</div>
+        <div id="resultRecommendationText" class="text-xs text-on-surface-variant"></div>
+      </div>
+    </div>
+
+    <!-- Right Panel: Intelligence Output -->
+    <div class="lg:col-span-7 space-y-8">
+      <!-- Score & Core Stats -->
+      <div class="grid grid-cols-1 md:grid-cols-2 gap-6">
+        <!-- Score Circle Card -->
+        <div id="resultScoreCard" class="glass-panel p-8 rounded-2xl flex flex-col items-center justify-center relative overflow-hidden">
+          <div id="resultScoreGradient" class="absolute inset-0 pointer-events-none"></div>
+          <div class="relative w-[200px] h-[200px] flex items-center justify-center">
+            <svg class="w-full h-full transform -rotate-90">
+              <circle class="text-surface-container-highest" cx="100" cy="100" fill="transparent" r="90" stroke="currentColor" stroke-width="6"></circle>
+              <circle id="resultArc" cx="100" cy="100" fill="transparent" r="90" stroke="currentColor" stroke-linecap="round" stroke-width="10" stroke-dasharray="565.48" stroke-dashoffset="565.48"></circle>
+            </svg>
+            <div class="absolute inset-0 flex flex-col items-center justify-center">
+              <span id="resultScorePercent" class="text-5xl font-mono font-bold text-white tracking-tighter">--%</span>
+              <span id="resultScoreLabel" class="text-[10px] font-bold tracking-[0.3em] uppercase mt-1"></span>
+            </div>
+          </div>
+        </div>
+        <!-- Details Card -->
+        <div class="glass-panel p-8 rounded-2xl flex flex-col justify-between">
+          <div class="space-y-6">
+            <div class="group">
+              <div class="text-[10px] font-mono text-on-surface-variant tracking-widest uppercase mb-1">CLASSIFICATION</div>
+              <div id="resultClassification" class="text-2xl font-bold tracking-tight"></div>
+            </div>
+            <div class="group">
+              <div class="text-[10px] font-mono text-on-surface-variant tracking-widest uppercase mb-1">CONFIDENCE</div>
+              <div id="resultConfidence" class="text-2xl font-mono font-medium text-white"></div>
+            </div>
+            <div class="group">
+              <div class="text-[10px] font-mono text-on-surface-variant tracking-widest uppercase mb-1">ANALYSIS DEPTH</div>
+              <div id="resultAnalysisDepth" class="text-sm text-on-surface">Linguistic + Pattern Analysis</div>
+            </div>
+          </div>
+        </div>
+      </div>
+
+      <!-- Threat Indicators -->
+      <div class="glass-panel p-8 rounded-2xl">
+        <h3 id="resultIndicatorsTitle" class="font-mono text-[10px] uppercase tracking-widest text-on-surface-variant mb-6 flex items-center gap-2">
+          <span class="material-symbols-outlined text-xs">radar</span>
+          THREAT INDICATORS
+        </h3>
+        <div id="resultIndicatorsContainer" class="flex flex-wrap gap-4">
+          <!-- Dynamically populated -->
+        </div>
+      </div>
+
+      <!-- Action Buttons -->
+      <div class="flex flex-col sm:flex-row gap-4 pt-4">
+        <button id="downloadReportBtn"
+          class="flex-1 bg-surface-container-high hover:bg-surface-container-highest text-white font-semibold
+                 py-4 px-6 rounded-xl flex items-center justify-center gap-3 border border-outline-variant/10
+                 transition-all active:scale-[0.98]">
+          <span class="material-symbols-outlined">download</span>
+          DOWNLOAD INTELLIGENCE BRIEF
+        </button>
+        <button id="newAnalysisBtn"
+          class="flex-1 bg-surface-container-high hover:bg-surface-container-highest text-on-surface font-bold
+                 py-4 px-6 rounded-xl flex items-center justify-center gap-3 border border-outline-variant/10
+                 transition-all active:scale-[0.98]">
+          New Analysis
+          <span class="material-symbols-outlined">arrow_forward</span>
+        </button>
+      </div>
+    </div>
+  </div>
+
+  <!-- System Log Section -->
+  <div class="mt-16 pt-12 border-t border-outline-variant/10">
+    <div class="grid grid-cols-1 md:grid-cols-3 gap-12">
+      <div class="space-y-4">
+        <div class="font-mono text-[9px] uppercase tracking-widest text-on-surface-variant">Linguistic Markers</div>
+        <div id="resultLinguistic" class="text-xs text-on-surface-variant leading-relaxed"></div>
+      </div>
+      <div class="space-y-4">
+        <div class="font-mono text-[9px] uppercase tracking-widest text-on-surface-variant">Domain Intelligence</div>
+        <div id="resultDomain" class="text-xs text-on-surface-variant leading-relaxed"></div>
+      </div>
+      <div class="space-y-4">
+        <div class="font-mono text-[9px] uppercase tracking-widest text-on-surface-variant">AI Confidence Map</div>
+        <div class="flex items-center gap-2 h-4 w-full bg-surface-container rounded-full overflow-hidden">
+          <div id="resultConfBar1" class="h-full transition-all duration-700" style="width: 0%"></div>
+          <div id="resultConfBar2" class="h-full transition-all duration-700" style="width: 0%"></div>
+        </div>
+        <div class="flex justify-between font-mono text-[8px] text-on-surface-variant uppercase">
+          <span id="resultHeuristicLabel">Heuristic: --</span>
+          <span id="resultNeuralLabel">Neural: --</span>
+        </div>
+      </div>
+    </div>
+  </div>
+</main>
+
+<!-- Footer -->
+<footer class="max-w-[1100px] mx-auto py-12 px-8 flex justify-between items-center opacity-40">
+  <div class="text-[12px] font-mono tracking-widest uppercase">System Status: Nominal</div>
+  <div class="text-[12px] font-mono tracking-widest uppercase">©2026 Sentinel Core Systems</div>
+</footer>
+</div>
+
+<!-- ============================================================ -->
+<!-- JAVASCRIPT: Backend Wiring & State Management                -->
+<!-- ============================================================ -->
+<script>
+(function() {
+    // ── State ─────────────────────────────────────────────────────────────
+    let lastAnalysisData = null;
+    let currentView = 'idle';   // 'idle' | 'result'
+    let currentMode = 'text';   // 'text' | 'image'
+
+    // ── DOM References ─────────────────────────────────────────────────────
+    const viewIdle              = document.getElementById('viewIdle');
+    const viewResult            = document.getElementById('viewResult');
+    const messageInput          = document.getElementById('messageInput');
+    const analyzeBtn            = document.getElementById('analyzeBtn');
+    const downloadReportBtn     = document.getElementById('downloadReportBtn');
+    const newAnalysisBtn        = document.getElementById('newAnalysisBtn');
+    const hudStatusText         = document.getElementById('hudStatusText');
+    const scannerModeLabel      = document.getElementById('scannerModeLabel');
+
+    // Mode toggle
+    const btnTextMode           = document.getElementById('btnTextMode');
+    const btnImageMode          = document.getElementById('btnImageMode');
+    const textZone              = document.getElementById('textZone');
+    const imageZone             = document.getElementById('imageZone');
+    const dropZone              = document.getElementById('dropZone');
+    const dropPlaceholder       = document.getElementById('dropPlaceholder');
+    const imgInput              = document.getElementById('imgInput');
+    const imgPreview            = document.getElementById('imgPreview');
+    const imgOverlay            = document.getElementById('imgOverlay');
+    const imgFilename           = document.getElementById('imgFilename');
+    const ocrPreviewBox         = document.getElementById('ocrPreviewBox');
+    const ocrPreviewText        = document.getElementById('ocrPreviewText');
+
+    // Result DOM
+    const resultIncidentBadge   = document.getElementById('resultIncidentBadge');
+    const resultHeadline        = document.getElementById('resultHeadline');
+    const resultInputBadge      = document.getElementById('resultInputBadge');
+    const resultSourceLabel     = document.getElementById('resultSourceLabel');
+    const resultMessageDisplay  = document.getElementById('resultMessageDisplay');
+    const resultRecommendation  = document.getElementById('resultRecommendation');
+    const resultRecommendationLabel = document.getElementById('resultRecommendationLabel');
+    const resultRecommendationText  = document.getElementById('resultRecommendationText');
+    const resultScoreCard       = document.getElementById('resultScoreCard');
+    const resultScoreGradient   = document.getElementById('resultScoreGradient');
+    const resultArc             = document.getElementById('resultArc');
+    const resultScorePercent    = document.getElementById('resultScorePercent');
+    const resultScoreLabel      = document.getElementById('resultScoreLabel');
+    const resultClassification  = document.getElementById('resultClassification');
+    const resultConfidence      = document.getElementById('resultConfidence');
+    const resultAnalysisDepth   = document.getElementById('resultAnalysisDepth');
+    const resultIndicatorsTitle = document.getElementById('resultIndicatorsTitle');
+    const resultIndicatorsContainer = document.getElementById('resultIndicatorsContainer');
+    const resultLinguistic      = document.getElementById('resultLinguistic');
+    const resultDomain          = document.getElementById('resultDomain');
+    const resultConfBar1        = document.getElementById('resultConfBar1');
+    const resultConfBar2        = document.getElementById('resultConfBar2');
+    const resultHeuristicLabel  = document.getElementById('resultHeuristicLabel');
+    const resultNeuralLabel     = document.getElementById('resultNeuralLabel');
+
+    // ── Mode Switching ─────────────────────────────────────────────────────
+    window.switchMode = function(mode) {
+        currentMode = mode;
+        const isImage = mode === 'image';
+
+        textZone.style.display  = isImage ? 'none'  : 'block';
+        imageZone.style.display = isImage ? 'block' : 'none';
+
+        // Active pill: filled purple bg
+        const activeClasses   = ['bg-[#7C6FFF]/15', 'text-[#7C6FFF]', 'border', 'border-[#7C6FFF]/20'];
+        const inactiveClasses = ['bg-transparent', 'text-[#4E5A6E]', 'border', 'border-transparent'];
+
+        if (isImage) {
+            // IMAGE active
+            btnImageMode.className = btnImageMode.className
+                .replace('bg-transparent', 'bg-[#7C6FFF]/15')
+                .replace('text-[#4E5A6E]', 'text-[#7C6FFF]')
+                .replace('border-transparent', 'border-[#7C6FFF]/20');
+            // TEXT inactive
+            btnTextMode.className = btnTextMode.className
+                .replace('bg-[#7C6FFF]/15', 'bg-transparent')
+                .replace('text-[#7C6FFF]', 'text-[#4E5A6E]')
+                .replace('border-[#7C6FFF]/20', 'border-transparent');
+        } else {
+            // TEXT active
+            btnTextMode.className = btnTextMode.className
+                .replace('bg-transparent', 'bg-[#7C6FFF]/15')
+                .replace('text-[#4E5A6E]', 'text-[#7C6FFF]')
+                .replace('border-transparent', 'border-[#7C6FFF]/20');
+            // IMAGE inactive
+            btnImageMode.className = btnImageMode.className
+                .replace('bg-[#7C6FFF]/15', 'bg-transparent')
+                .replace('text-[#7C6FFF]', 'text-[#4E5A6E]')
+                .replace('border-[#7C6FFF]/20', 'border-transparent');
+        }
+
+        // Reset OCR preview when switching back to text
+        if (!isImage) {
+            ocrPreviewBox.classList.add('hidden');
+        }
+    };
+
+    // ── Drag & Drop Handlers ───────────────────────────────────────────────
+    window.handleDragOver = function(e) {
+        e.preventDefault();
+        dropZone.classList.add('drag-over');
+    };
+
+    window.handleDragLeave = function(e) {
+        dropZone.classList.remove('drag-over');
+    };
+
+    window.handleDrop = function(e) {
+        e.preventDefault();
+        dropZone.classList.remove('drag-over');
+        const file = e.dataTransfer.files[0];
+        if (file && file.type.startsWith('image/')) {
+            // Manually set input files via DataTransfer (modern browsers)
+            try {
+                const dt = new DataTransfer();
+                dt.items.add(file);
+                imgInput.files = dt.files;
+            } catch (_) { /* Safari fallback – preview still works */ }
+            previewFile(file);
+        }
+    };
+
+    window.handleFileSelect = function(e) {
+        const file = e.target.files[0];
+        if (file) previewFile(file);
+    };
+
+    function previewFile(file) {
+        const reader = new FileReader();
+        reader.onload = function(e) {
+            imgPreview.src = e.target.result;
+            imgPreview.classList.remove('hidden');
+            dropPlaceholder.style.display = 'none';
+            imgFilename.textContent = file.name;
+            imgOverlay.classList.remove('hidden');
+            // Reset OCR preview on new image
+            ocrPreviewBox.classList.add('hidden');
+            ocrPreviewText.textContent = '';
+        };
+        reader.readAsDataURL(file);
+    }
+
+    // ── View Switching ─────────────────────────────────────────────────────
+    function showView(name) {
+        if (name === 'idle') {
+            viewResult.classList.remove('view-visible');
+            viewResult.classList.add('view-hidden');
+            setTimeout(() => {
+                viewIdle.classList.remove('view-hidden');
+                viewIdle.classList.add('view-visible');
+            }, 100);
+        } else {
+            viewIdle.classList.remove('view-visible');
+            viewIdle.classList.add('view-hidden');
+            setTimeout(() => {
+                viewResult.classList.remove('view-hidden');
+                viewResult.classList.add('view-visible');
+                window.scrollTo({ top: 0, behavior: 'smooth' });
+            }, 100);
+        }
+        currentView = name;
+    }
+
+    // ── Processing State ───────────────────────────────────────────────────
+    function setProcessingState(isProcessing, label) {
+        const btnLabel = label || (currentMode === 'image' ? 'READING SCREENSHOT...' : 'PROCESSING...');
+        if (isProcessing) {
+            analyzeBtn.disabled = true;
+            analyzeBtn.innerHTML = `
+                <span class="inline-block w-4 h-4 border-2 border-white/30 border-t-white rounded-full animate-spin mr-2"></span>
+                ${btnLabel}
+            `;
+            analyzeBtn.classList.add('opacity-80', 'cursor-wait');
+            hudStatusText.innerHTML = `
+                <span class="text-[10px] text-[#7C6FFF] tracking-[0.15em] font-semibold uppercase">NEURAL PROCESSING</span>
+                <div class="flex gap-1.5 mt-1">
+                    <span class="w-1.5 h-1.5 bg-[#7C6FFF] rounded-full animate-pulse"></span>
+                    <span class="w-1.5 h-1.5 bg-[#7C6FFF]/60 rounded-full animate-pulse" style="animation-delay: 0.2s"></span>
+                    <span class="w-1.5 h-1.5 bg-[#7C6FFF]/30 rounded-full animate-pulse" style="animation-delay: 0.4s"></span>
+                </div>
+            `;
+            scannerModeLabel.textContent = 'SCANNER_ACTIVE_MODE';
+        } else {
+            analyzeBtn.disabled = false;
+            analyzeBtn.innerHTML = 'RUN ANALYSIS';
+            analyzeBtn.classList.remove('opacity-80', 'cursor-wait');
+            hudStatusText.innerHTML = `
+                <span class="text-[10px] text-[#2E3A4E] tracking-[0.15em] font-semibold uppercase">AWAITING ANALYSIS</span>
+                <div class="flex gap-1">
+                    <span class="w-1 h-1 bg-[#2E3A4E] rounded-full"></span>
+                    <span class="w-1 h-1 bg-[#2E3A4E]/50 rounded-full"></span>
+                    <span class="w-1 h-1 bg-[#2E3A4E]/20 rounded-full"></span>
+                </div>
+            `;
+            scannerModeLabel.textContent = 'SCANNER_IDLE_MODE';
+        }
+    }
+
+    // ── Generate Incident ID ───────────────────────────────────────────────
+    function generateIncidentId() {
+        const num = Math.floor(1000 + Math.random() * 9000);
+        const suffix = String.fromCharCode(65 + Math.floor(Math.random() * 26));
+        return `Incident #${num}-${suffix}`;
+    }
+
+    // ── SVG Arc Calculation ────────────────────────────────────────────────
+    function setArcPercentage(percent) {
+        const circumference = 2 * Math.PI * 90;
+        const offset = circumference - (percent / 100) * circumference;
+        resultArc.style.strokeDasharray = circumference;
+        resultArc.style.strokeDashoffset = circumference;
+        requestAnimationFrame(() => {
+            resultArc.style.transition = 'stroke-dashoffset 1.2s ease-out';
+            resultArc.style.strokeDashoffset = offset;
+        });
+    }
+
+    // ── Populate Result View ───────────────────────────────────────────────
+    function populateResult(data, originalMessage, inputMethod) {
+        const isScam      = data.label === 'SCAM';
+        const scamProb    = data.scam_probability;
+        const safeProb    = data.safe_probability;
+        const riskLevel   = data.risk_level;
+        const signals     = data.signals || [];
+        const isOCR       = (inputMethod === 'ocr');
+
+        const scamPercent = Math.round(scamProb * 100);
+        const safePercent = Math.round(safeProb * 100);
+        const confidence  = Math.max(scamPercent, safePercent);
+
+        const accentColor = isScam ? '#ff5262' : '#00E87A';
+        const glowClass   = isScam ? 'glow-red' : 'safe-glow';
+
+        // ─ Header ─
+        resultIncidentBadge.textContent = generateIncidentId();
+        resultIncidentBadge.style.color = accentColor;
+        resultIncidentBadge.style.borderColor = accentColor + '4D';
+
+        resultHeadline.textContent = isScam ? 'Threat Detected' : 'No Threat Detected';
+        resultHeadline.style.color = accentColor;
+
+        // ─ Input method badge ─
+        if (isOCR) {
+            resultInputBadge.textContent  = 'OCR · SCREENSHOT INPUT';
+            resultInputBadge.style.color  = '#7C6FFF';
+            resultInputBadge.style.borderColor = 'rgba(124,111,255,0.3)';
+            resultSourceLabel.textContent = 'Source Content (Screenshot — OCR Extracted)';
+        } else {
+            resultInputBadge.textContent  = 'HYBRID INFERENCE MODE';
+            resultInputBadge.style.color  = '';
+            resultInputBadge.style.borderColor = '';
+            resultSourceLabel.textContent = 'Source Content (SMS/Text)';
+        }
+
+        // ─ Message display ─
+        resultMessageDisplay.value = originalMessage;
+
+        // ─ Analysis Depth label ─
+        resultAnalysisDepth.textContent = isOCR
+            ? 'OCR Extraction + Linguistic + Pattern'
+            : 'Linguistic + Pattern Analysis';
+
+        // ─ Recommendation ─
+        resultRecommendation.className = `flex flex-col gap-2 p-4 rounded-r-lg border-l-2`;
+        resultRecommendation.style.borderColor = accentColor;
+        resultRecommendation.style.background = isScam ? 'rgba(255,82,98,0.05)' : 'rgba(0,232,122,0.05)';
+        resultRecommendationLabel.style.color = accentColor;
+
+        if (isScam) {
+            resultRecommendationText.textContent = riskLevel === 'HIGH'
+                ? 'Isolate communication channel immediately. High probability of credential harvesting or social engineering attack. Do NOT share any personal information.'
+                : 'Exercise caution. Several suspicious patterns detected. Verify through official channels before responding.';
+        } else {
+            resultRecommendationText.textContent = 'Content verified. No immediate risks identified. Message classification suggests legitimate communication.';
+        }
+
+        // ─ Score Circle ─
+        resultScoreCard.className = `glass-panel ${glowClass} p-8 rounded-2xl flex flex-col items-center justify-center relative overflow-hidden`;
+        resultScoreGradient.className = `absolute inset-0 bg-gradient-to-br ${isScam ? 'from-tertiary-container/5' : 'from-secondary-container/5'} to-transparent pointer-events-none`;
+
+        resultArc.classList.remove('text-tertiary-container', 'text-secondary');
+        resultArc.classList.add(isScam ? 'text-tertiary-container' : 'text-secondary');
+
+        resultScorePercent.textContent = scamPercent + '%';
+        resultScoreLabel.textContent   = isScam ? (riskLevel === 'HIGH' ? 'HIGH RISK' : 'MEDIUM RISK') : 'SAFE';
+        resultScoreLabel.style.color   = accentColor;
+
+        setArcPercentage(scamPercent);
+
+        // ─ Details ─
+        resultClassification.textContent = isScam ? 'SCAM DETECTED' : 'LEGITIMATE';
+        resultClassification.style.color = accentColor;
+        resultConfidence.textContent     = confidence.toFixed(1) + '%';
+
+        // ─ Threat Indicators ─
+        resultIndicatorsContainer.innerHTML = '';
+        if (isScam && signals.length > 0) {
+            resultIndicatorsTitle.innerHTML = `<span class="material-symbols-outlined text-xs">radar</span> THREAT INDICATORS`;
+            const iconMap = {
+                'arrest or legal authority threat': 'security',
+                'urgency / time pressure': 'priority_high',
+                'payment demand with urgency': 'payments',
+                'phishing link / click-bait': 'link',
+                'account suspension threat': 'lock',
+                'prize / lottery scam': 'emoji_events',
+                'credential / remote access request': 'key',
+                'digital arrest pattern': 'gavel',
+                'isolation / secrecy demand': 'visibility_off',
+                'document / id fraud': 'badge',
+            };
+            signals.forEach(sig => {
+                const sigLower = sig.toLowerCase();
+                let icon = 'warning';
+                for (const [key, val] of Object.entries(iconMap)) {
+                    if (sigLower.includes(key) || key.includes(sigLower.replace(/^\w/, ''))) {
+                        icon = val; break;
+                    }
+                }
+                const chip = document.createElement('div');
+                chip.className = 'px-5 py-3 rounded-lg border border-tertiary-container/20 bg-tertiary-container/[0.08] flex items-center gap-3 group hover:bg-tertiary-container/[0.12] transition-colors';
+                chip.innerHTML = `
+                    <span class="material-symbols-outlined text-tertiary-container text-sm">${icon}</span>
+                    <span class="font-mono text-xs font-bold text-tertiary-container/85 tracking-tighter uppercase">${sig}</span>
+                `;
+                resultIndicatorsContainer.appendChild(chip);
+            });
+        } else {
+            resultIndicatorsTitle.innerHTML = `<span class="material-symbols-outlined text-xs">check_circle</span> THREAT STATUS`;
+            const chip = document.createElement('div');
+            chip.className = 'px-5 py-3 rounded-lg border border-secondary/20 bg-secondary/[0.08] flex items-center gap-3 group hover:bg-secondary/[0.12] transition-colors';
+            chip.innerHTML = `
+                <span class="material-symbols-outlined text-secondary text-sm">verified</span>
+                <span class="font-mono text-xs font-bold text-secondary/85 tracking-tighter uppercase">NO THREATS DETECTED</span>
+            `;
+            resultIndicatorsContainer.appendChild(chip);
+        }
+
+        // ─ New Analysis button styling ─
+        newAnalysisBtn.className = isScam
+            ? 'flex-1 bg-gradient-to-r from-tertiary-container to-[#FF4058] hover:opacity-90 text-on-tertiary font-bold py-4 px-6 rounded-xl flex items-center justify-center gap-3 shadow-lg shadow-tertiary-container/20 transition-all active:scale-[0.98]'
+            : 'flex-1 bg-surface-container-high hover:bg-surface-container-highest text-on-surface font-bold py-4 px-6 rounded-xl flex items-center justify-center gap-3 border border-outline-variant/10 transition-all active:scale-[0.98]';
+
+        // ─ System Log ─
+        if (isScam) {
+            resultLinguistic.innerHTML = `System detected artificial pressure nodes typical of social engineering campaigns. ${signals.length} risk indicator(s) flagged during analysis.${isOCR ? ' <span class="text-[#7C6FFF]/60">[Source: OCR]</span>' : ''}`;
+            resultDomain.innerHTML     = `Content analysis flagged suspicious patterns. <span class="text-tertiary-container underline underline-offset-4 decoration-tertiary-container/30">High-risk indicators present</span>. Exercise extreme caution.`;
+            resultConfBar1.style.width = scamPercent + '%';
+            resultConfBar1.className   = 'h-full bg-tertiary-container transition-all duration-700';
+            resultConfBar2.style.width = safePercent + '%';
+            resultConfBar2.className   = 'h-full bg-surface-variant transition-all duration-700';
+            resultHeuristicLabel.textContent = riskLevel === 'HIGH' ? 'Heuristic: High' : 'Heuristic: Medium';
+            resultNeuralLabel.textContent    = `Neural: ${scamPercent}.${Math.floor(Math.random()*9)}`;
+        } else {
+            resultLinguistic.innerHTML = `System identified <span class="text-white">Natural language patterns</span>. Absence of artificial pressure nodes or common phishing keywords. Sentiment is professional.${isOCR ? ' <span class="text-[#7C6FFF]/60">[Source: OCR]</span>' : ''}`;
+            resultDomain.innerHTML     = `Content verified. <span class="text-secondary underline underline-offset-4 decoration-secondary/30">No suspicious patterns</span>. Metadata consistent with legitimate communication.`;
+            resultConfBar1.style.width = scamPercent + '%';
+            resultConfBar1.className   = 'h-full bg-secondary transition-all duration-700';
+            resultConfBar2.style.width = safePercent + '%';
+            resultConfBar2.className   = 'h-full bg-surface-variant transition-all duration-700';
+            resultHeuristicLabel.textContent = 'Low heuristic score';
+            resultNeuralLabel.textContent    = `Neural: ${safePercent}.${Math.floor(Math.random()*9)}% Legit`;
+        }
+    }
+
+    // ── TEXT ANALYSIS ──────────────────────────────────────────────────────
+    async function runTextAnalysis() {
+        const text = messageInput.value.trim();
+        if (!text) {
+            messageInput.classList.add('border-tertiary-container/60');
+            messageInput.setAttribute('placeholder', '⚠ Please paste a message for analysis...');
+            setTimeout(() => {
+                messageInput.classList.remove('border-tertiary-container/60');
+                messageInput.setAttribute('placeholder', 'Paste any suspicious message, URL, or code snippet for immediate neural evaluation...');
+            }, 2000);
+            return;
+        }
+
+        setProcessingState(true);
+        try {
+            const response = await fetch('/analyze', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({ message: text })
+            });
+            if (!response.ok) throw new Error('Server error: ' + response.status);
+
+            const data = await response.json();
+            lastAnalysisData = {
+                message: text,
+                risk_score: (data.scam_probability * 100).toFixed(1),
+                risk_level: data.risk_level || (data.label === 'SCAM' ? 'HIGH' : 'LOW'),
+                signals: data.signals || []
+            };
+
+            populateResult(data, text, 'text');
+            setProcessingState(false);
+            showView('result');
+
+        } catch (error) {
+            console.error('Analysis error:', error);
+            setProcessingState(false);
+            hudStatusText.innerHTML = `
+                <span class="text-[10px] text-tertiary-container tracking-[0.15em] font-semibold uppercase">ANALYSIS FAILED</span>
+                <div class="text-[8px] text-on-surface-variant mt-1">Check connection and retry</div>
+            `;
+        }
+    }
+
+    // ── OCR ANALYSIS ───────────────────────────────────────────────────────
+    async function runOCRAnalysis() {
+        const file = imgInput.files[0];
+        if (!file) {
+            // Flash the drop zone border
+            dropZone.style.borderColor = 'rgba(255,82,98,0.5)';
+            setTimeout(() => { dropZone.style.borderColor = ''; }, 1800);
+            return;
+        }
+
+        setProcessingState(true, 'READING SCREENSHOT...');
+
+        try {
+            const formData = new FormData();
+            formData.append('image', file);
+
+            const response = await fetch('/ocr_analyze', {
+                method: 'POST',
+                body: formData
+            });
+
+            const data = await response.json();
+
+            if (data.error) {
+                setProcessingState(false);
+                // Show error in the OCR preview area without disrupting layout
+                ocrPreviewText.textContent = '⚠ ' + data.error;
+                ocrPreviewBox.classList.remove('hidden');
+                return;
+            }
+
+            const extractedText = data.extracted_text;
+
+            // Show extracted text preview for user verification
+            ocrPreviewText.textContent = extractedText;
+            ocrPreviewBox.classList.remove('hidden');
+
+            // Also populate the text textarea (for reference if user switches mode)
+            messageInput.value = extractedText;
+
+            lastAnalysisData = {
+                message: extractedText,
+                risk_score: (data.scam_probability * 100).toFixed(1),
+                risk_level: data.risk_level || (data.label === 'SCAM' ? 'HIGH' : 'LOW'),
+                signals: data.signals || []
+            };
+
+            populateResult(data, extractedText, 'ocr');
+            setProcessingState(false);
+            showView('result');
+
+        } catch (err) {
+            console.error('OCR error:', err);
+            setProcessingState(false);
+            ocrPreviewText.textContent = '⚠ Network error. Make sure the server is running.';
+            ocrPreviewBox.classList.remove('hidden');
+        }
+    }
+
+    // ── ANALYZE BUTTON — branches on mode ─────────────────────────────────
+    analyzeBtn.addEventListener('click', function(e) {
+        e.preventDefault();
+        if (currentMode === 'image') {
+            runOCRAnalysis();
+        } else {
+            runTextAnalysis();
+        }
+    });
+
+    // ── DOWNLOAD REPORT ────────────────────────────────────────────────────
+    downloadReportBtn.addEventListener('click', async function() {
+        if (!lastAnalysisData) return;
+
+        const originalText = this.innerHTML;
+        this.innerHTML = `
+            <span class="inline-block w-4 h-4 border-2 border-white/30 border-t-white rounded-full animate-spin"></span>
+            GENERATING...
+        `;
+        this.disabled = true;
+
+        try {
+            const response = await fetch('/download_report', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify(lastAnalysisData)
+            });
+            if (!response.ok) throw new Error('Server error: ' + response.status);
+
+            const blob = await response.blob();
+            const url  = window.URL.createObjectURL(blob);
+            const a    = document.createElement('a');
+            a.href = url;
+            a.download = 'SentinelAI_Report.pdf';
+            document.body.appendChild(a);
+            a.click();
+            document.body.removeChild(a);
+            window.URL.revokeObjectURL(url);
+
+            this.innerHTML = `<span class="material-symbols-outlined">check_circle</span> DOWNLOADED`;
+            setTimeout(() => { this.innerHTML = originalText; }, 2500);
+
+        } catch (err) {
+            console.error('Download error:', err);
+            this.innerHTML = `<span class="material-symbols-outlined">error</span> FAILED — RETRY`;
+            setTimeout(() => { this.innerHTML = originalText; }, 3000);
+        } finally {
+            this.disabled = false;
+        }
+    });
+
+    // ── NEW ANALYSIS ───────────────────────────────────────────────────────
+    newAnalysisBtn.addEventListener('click', function() {
+        messageInput.value = '';
+        lastAnalysisData   = null;
+
+        // Reset image zone
+        imgInput.value      = '';
+        imgPreview.src      = '';
+        imgPreview.classList.add('hidden');
+        imgOverlay.classList.add('hidden');
+        dropPlaceholder.style.display = '';
+        ocrPreviewBox.classList.add('hidden');
+        ocrPreviewText.textContent = '';
+
+        showView('idle');
+    });
+
+    // ── Keyboard shortcut: Ctrl+Enter ─────────────────────────────────────
+    messageInput.addEventListener('keydown', function(e) {
+        if ((e.ctrlKey || e.metaKey) && e.key === 'Enter') {
+            analyzeBtn.click();
+        }
+    });
+
+})();
+</script>
+</body>
+</html>

models/train_model_v2.py

@@ -0,0 +1,144 @@
+import os
+import pandas as pd
+import torch
+from sklearn.model_selection import train_test_split
+from transformers import DistilBertTokenizerFast, DistilBertForSequenceClassification, Trainer, TrainingArguments
+from datasets import Dataset
+import numpy as np
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+from sklearn.utils.class_weight import compute_class_weight
+
+# Load dataset
+df = pd.read_csv("D:\Sentinel\data\sentinel_dataset_expanded.csv")
+
+# Basic cleaning
+df = df.dropna()
+df["text"] = df["text"].astype(str)
+
+print(f"Dataset size: {len(df)}")
+print(f"Label distribution: {df['label'].value_counts().to_dict()}")
+print(f"\nAverage text length: {df['text'].str.len().mean():.1f} characters")
+
+# Train-test split
+train_texts, val_texts, train_labels, val_labels = train_test_split(
+    df["text"].tolist(),
+    df["label"].tolist(),
+    test_size=0.2,
+    random_state=42,
+    stratify=df["label"].tolist()  # Ensure balanced split
+)
+
+# Compute class weights for balanced training
+class_weights = compute_class_weight(
+    class_weight='balanced',
+    classes=np.unique(train_labels),
+    y=train_labels
+)
+class_weights = torch.tensor(class_weights, dtype=torch.float)
+print(f"\nClass weights: SAFE={class_weights[0]:.4f}, SCAM={class_weights[1]:.4f}")
+print(f"Training set - SAFE: {train_labels.count(0)}, SCAM: {train_labels.count(1)}")
+
+# Tokenizer
+tokenizer = DistilBertTokenizerFast.from_pretrained("distilbert-base-uncased")
+
+train_encodings = tokenizer(train_texts, truncation=True, padding=True, max_length=128)
+val_encodings = tokenizer(val_texts, truncation=True, padding=True, max_length=128)
+
+train_dataset = Dataset.from_dict({
+    "input_ids": train_encodings["input_ids"],
+    "attention_mask": train_encodings["attention_mask"],
+    "labels": train_labels
+})
+
+val_dataset = Dataset.from_dict({
+    "input_ids": val_encodings["input_ids"],
+    "attention_mask": val_encodings["attention_mask"],
+    "labels": val_labels
+})
+
+# Model with class weights
+model = DistilBertForSequenceClassification.from_pretrained(
+    "distilbert-base-uncased",
+    num_labels=2
+)
+
+# Custom trainer class to use class weights
+class WeightedTrainer(Trainer):
+    def compute_loss(self, model, inputs, return_outputs=False, **kwargs):
+        labels = inputs.pop("labels")
+        outputs = model(**inputs)
+        logits = outputs.logits
+        loss_fct = torch.nn.CrossEntropyLoss(weight=class_weights.to(logits.device))
+        loss = loss_fct(logits.view(-1, self.model.config.num_labels), labels.view(-1))
+        return (loss, outputs) if return_outputs else loss
+
+# Metrics
+def compute_metrics(pred):
+    labels = pred.label_ids
+    preds = np.argmax(pred.predictions, axis=1)
+    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
+    acc = accuracy_score(labels, preds)
+    
+    # Confusion matrix
+    cm = confusion_matrix(labels, preds)
+    print(f"\nConfusion Matrix:")
+    print(f"              Predicted SAFE  Predicted SCAM")
+    print(f"Actual SAFE:  {cm[0][0]:14d}  {cm[0][1]:14d}")
+    print(f"Actual SCAM:  {cm[1][0]:14d}  {cm[1][1]:14d}")
+    
+    return {
+        "accuracy": acc,
+        "f1": f1,
+        "precision": precision,
+        "recall": recall
+    }
+
+# Training args - MORE aggressive parameters
+training_args = TrainingArguments(
+    output_dir="./results",
+    num_train_epochs=10,  # Increased to 10 epochs
+    per_device_train_batch_size=16,
+    per_device_eval_batch_size=16,
+    warmup_steps=50,  # Reduced warmup
+    weight_decay=0.01,
+    learning_rate=3e-5,  # Slightly higher learning rate
+    logging_dir="./logs",
+    logging_steps=5,
+    eval_strategy="epoch",
+    save_strategy="epoch",
+    load_best_model_at_end=True,
+    metric_for_best_model="f1",
+    save_total_limit=2
+)
+
+trainer = WeightedTrainer(
+    model=model,
+    args=training_args,
+    train_dataset=train_dataset,
+    eval_dataset=val_dataset,
+    compute_metrics=compute_metrics
+)
+
+print("\n" + "="*60)
+print("Starting training with 10 epochs...")
+print("="*60)
+trainer.train()
+
+print("\n" + "="*60)
+print("Final Evaluation...")
+print("="*60)
+eval_results = trainer.evaluate()
+print(f"\nFinal Evaluation Results:")
+print(f"  Accuracy: {eval_results['eval_accuracy']:.4f}")
+print(f"  F1 Score: {eval_results['eval_f1']:.4f}")
+print(f"  Precision: {eval_results['eval_precision']:.4f}")
+print(f"  Recall: {eval_results['eval_recall']:.4f}")
+
+script_dir = os.path.dirname(os.path.abspath(__file__))
+save_path = os.path.join(script_dir, "sentinel_model")
+model.save_pretrained(save_path)
+tokenizer.save_pretrained(save_path)
+
+print(f"\n{'='*60}")
+print(f"Model training complete and saved to: {save_path}")
+print("="*60)

requirements.txt

@@ -0,0 +1,13 @@
+# ── Production dependencies (app runtime only) ────────────────────────────────
+Flask==3.0.3
+torch==2.2.2
+transformers==4.40.2
+numpy==1.26.4
+reportlab==4.1.0
+pytesseract==0.3.13
+Pillow==10.3.0
+
+# ── Dev / Training only (not needed by the running app) ───────────────────────
+# pandas==2.2.2
+# scikit-learn==1.4.2
+# datasets==2.19.1