Merge branch 'main' of https://huggingface.co/spaces/gaurv007/ClauseGuard

DEPLOY.md

@@ -1,11 +1,11 @@
-# ClauseGuard — Deployment Guide
+# ClauseGuard — Deployment Guide v3.0
 
 ## What's running now
 
 | Component | Status | URL |
 |-----------|--------|-----|
 | Gradio demo | ✅ Live | https://huggingface.co/spaces/gaurv007/ClauseGuard |
-| ML model | ✅ On Hub | https://huggingface.co/gaurv007/clauseguard-legal-bert |
+| ML model | ✅ On Hub | https://huggingface.co/Mokshith31/legalbert-contract-clause-classification |
 | FastAPI backend | ❌ Needs host | Code ready in `api/` |
 | Next.js website | ❌ Needs Vercel | Code ready in `web/` |
 | Chrome extension | ❌ Needs testing | Code ready in `extension/` |
@@ -19,24 +19,15 @@ The extension works WITHOUT the backend — it uses local regex fallback.
 ### Steps:
 ```
 1. Download the extension/ folder from the repo
-   → Go to https://huggingface.co/spaces/gaurv007/ClauseGuard/tree/main/extension
-   → Or clone: git clone https://huggingface.co/spaces/gaurv007/ClauseGuard
-
 2. Open Chrome → chrome://extensions/
-
 3. Toggle ON "Developer mode" (top right)
-
 4. Click "Load unpacked"
-
 5. Select the extension/ folder
-
 6. Visit any Terms of Service page (try spotify.com/legal or airbnb.com/terms)
-
 7. The extension will auto-scan and highlight unfair clauses
 ```
 
-The extension uses local pattern matching until you point it at a running backend.
-To connect it to the API, change `API_BASE` in `background.js`.
+To connect to a running API, change `API_BASE` in `background.js`.
 
 ---
 
@@ -49,84 +40,29 @@ Create a new Space with Docker SDK:
 1. Go to https://huggingface.co/new-space
 2. Name: `clauseguard-api`
 3. SDK: Docker
-4. Create this `Dockerfile` in the Space:
-
-```dockerfile
-FROM python:3.12-slim
-WORKDIR /app
-COPY api/requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
-COPY api/ .
-EXPOSE 7860
-CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]
-```
-
-5. Copy `api/main.py`, `api/auth.py`, `api/requirements.txt` into the Space
-6. Your API will be at: `https://gaurv007-clauseguard-api.hf.space`
+4. Copy `api/main.py`, `api/auth.py`, `api/requirements.txt` into the Space
+5. Your API will be at: `https://gaurv007-clauseguard-api.hf.space`
 
 ### Option B: Railway (free tier, auto-deploy)
 
 ```bash
-# Install Railway CLI
-npm install -g @railway/cli
-
-# Login and deploy
 cd api/
 railway login
 railway init
 railway up
 ```
 
-Your API will get a URL like `https://clauseguard-api-production.up.railway.app`
-
-### Option C: Render (free tier)
-
-1. Go to https://render.com
-2. New → Web Service → Connect your Git repo
-3. Root directory: `api`
-4. Build command: `pip install -r requirements.txt`
-5. Start command: `uvicorn main:app --host 0.0.0.0 --port $PORT`
-
 ### After deploying the backend:
 
 Update `API_BASE` in `extension/background.js`:
 ```javascript
-const API_BASE = "https://your-backend-url.com";  // your deployed URL
-```
-
-Update `CLAUSEGUARD_API_URL` in `web/.env.local`:
-```
-CLAUSEGUARD_API_URL=https://your-backend-url.com
+const API_BASE = "https://your-backend-url.com";
 ```
 
 ---
 
 ## 3. Deploy the Website on Vercel (10 minutes)
 
-### Prerequisites:
-- GitHub account (to push the repo)
-- Vercel account (free at vercel.com)
-- Supabase project created
-- Stripe products created
-
-### Steps:
-
-```bash
-# 1. Push web/ folder to a GitHub repo
-cd web/
-git init
-git add .
-git commit -m "ClauseGuard website"
-git remote add origin https://github.com/YOUR_USERNAME/clauseguard-web.git
-git push -u origin main
-
-# 2. Go to vercel.com → New Project → Import the GitHub repo
-
-# 3. Set the Root Directory to: web
-
-# 4. Add environment variables in Vercel dashboard:
-```
-
 ### Required environment variables on Vercel:
 
 ```
@@ -135,10 +71,10 @@ NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=eyJ...
 SUPABASE_SERVICE_ROLE_KEY=eyJ...
 SUPABASE_JWT_SECRET=your-jwt-secret
 
-STRIPE_SECRET_KEY=sk_live_...
-STRIPE_WEBHOOK_SECRET=whsec_...
-STRIPE_PRO_PRICE_ID=price_...
-STRIPE_TEAM_PRICE_ID=price_...
+# Payment: Razorpay (used in web/components/checkout-button.tsx and schema.sql)
+NEXT_PUBLIC_RAZORPAY_KEY_ID=rzp_live_...
+RAZORPAY_KEY_SECRET=...
+RAZORPAY_WEBHOOK_SECRET=...
 
 RESEND_API_KEY=re_...
 
@@ -146,12 +82,8 @@ NEXT_PUBLIC_SITE_URL=https://your-domain.vercel.app
 CLAUSEGUARD_API_URL=https://your-backend-url.com
 ```
 
-5. Click Deploy
-6. Your site will be at: `https://clauseguard.vercel.app`
-
-### Custom domain:
-- In Vercel → Settings → Domains → Add `clauseguardweb.netlify.app`
-- Point your DNS A record to Vercel's IP
+> **Note:** The payment integration uses **Razorpay** (see `web/components/checkout-button.tsx`
+> and `web/lib/supabase/schema.sql` which has `razorpay_subscription_id` columns).
 
 ---
 
@@ -168,18 +100,17 @@ CLAUSEGUARD_API_URL=https://your-backend-url.com
 
 ---
 
-## 5. Setup Stripe (5 minutes)
+## 5. Setup Razorpay (5 minutes)
 
-1. Go to https://dashboard.stripe.com
-2. Products → Create:
-   - "ClauseGuard Pro" — $12/month recurring
-   - "ClauseGuard Team" — $49/month recurring
-3. Copy each product's Price ID → `STRIPE_PRO_PRICE_ID`, `STRIPE_TEAM_PRICE_ID`
-4. Developers → Webhooks → Add endpoint:
-   - URL: `https://your-site.vercel.app/api/stripe/webhook`
-   - Events: `customer.subscription.created`, `customer.subscription.updated`, `customer.subscription.deleted`, `invoice.payment_failed`
-5. Copy webhook signing secret → `STRIPE_WEBHOOK_SECRET`
-6. Settings → Billing → Customer Portal → Enable
+1. Go to https://dashboard.razorpay.com
+2. Create subscription plans:
+   - "ClauseGuard Pro" — ₹999/month or $12/month
+   - "ClauseGuard Team" — ₹3999/month or $49/month
+3. Settings → API Keys → Copy Key ID and Secret
+4. Settings → Webhooks → Add endpoint:
+   - URL: `https://your-site.vercel.app/api/webhooks/razorpay`
+   - Events: `subscription.activated`, `subscription.charged`, `subscription.cancelled`, `payment.failed`
+5. Copy webhook secret
 
 ---
 
@@ -187,8 +118,7 @@ CLAUSEGUARD_API_URL=https://your-backend-url.com
 
 1. Go to https://resend.com → Sign up
 2. API Keys → Create → Copy key → `RESEND_API_KEY`
-3. Domains → Add `clauseguardweb.netlify.app` → Add DNS records they give you
-4. Until domain is verified, emails send from `onboarding@resend.dev`
+3. Add your domain for email sending
 
 ---
 
@@ -197,7 +127,7 @@ CLAUSEGUARD_API_URL=https://your-backend-url.com
 ```
 1. Supabase (create project, run schema) — 5 min
 2. Backend (deploy to Railway/Render/HF) — 5 min
-3. Stripe (create products) — 5 min
+3. Razorpay (create plans) — 5 min
 4. Resend (get API key) — 2 min
 5. Vercel (deploy with all env vars) — 10 min
 6. Extension (update API_BASE, load unpacked) — 2 min

api/main.py

@@ -1,14 +1,13 @@
 """
-ClauseGuard — FastAPI Backend v2.0
+ClauseGuard — FastAPI Backend v3.0
 ══════════════════════════════════
-Features:
-  • 41 CUAD clause categories via fine-tuned Legal-BERT
-  • 4-tier risk scoring (Critical / High / Medium / Low)
-  • Legal NER: parties, dates, monetary values, jurisdictions, defined terms
-  • NLI contradiction & missing-clause detection
-  • Contract comparison engine
-  • Obligation tracker
-  • Compliance checker (GDPR, CCPA, SOX, HIPAA, FINRA)
+FIXED in v3.0:
+  • Imports shared modules (no code duplication)
+  • Fixed API schema to accept both {text} and {clauses} from extension
+  • Added rate limiting
+  • Added max text length validation
+  • Fixed CORS (removed wildcard)
+  • Added proper error responses
 """
 
 import os
@@ -22,526 +21,102 @@ from datetime import datetime
 
 import httpx
 import numpy as np
-from fastapi import FastAPI, HTTPException, Depends, Body
+from fastapi import FastAPI, HTTPException, Depends, Body, Request
 from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel, Field
 
 from auth import get_current_user, require_auth
 
+# ── Import shared modules ──
+# When deployed, these must be in the same directory or on PYTHONPATH
+import sys
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+try:
+    from app import (
+        split_clauses, classify_cuad, extract_entities,
+        detect_contradictions, compute_risk_score,
+        CUAD_LABELS, RISK_MAP, DESC_MAP, _model_status,
+        cuad_model, cuad_tokenizer
+    )
+    from obligations import extract_obligations
+    from compliance import check_compliance
+    from compare import compare_contracts
+    _SHARED_MODULES = True
+except ImportError:
+    _SHARED_MODULES = False
+    print("[API] WARNING: Could not import shared modules, using inline fallbacks")
+
 # ─── Config ───
-MODEL_PATH = os.environ.get("MODEL_PATH", "./clauseguard-model/final")
-ONNX_MODEL_PATH = os.environ.get("ONNX_MODEL_PATH", "./clauseguard-model-onnx")
-USE_ONNX = os.environ.get("USE_ONNX", "true").lower() == "true"
 SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
 SUPABASE_SERVICE_KEY = os.environ.get("SUPABASE_SERVICE_ROLE_KEY", "")
 HF_API_TOKEN = os.environ.get("HF_API_TOKEN", "")
 SAULLM_ENDPOINT = os.environ.get("SAULLM_ENDPOINT", "")
-
-# ─── CUAD Labels (41 categories) ───
-CUAD_LABELS = [
-    "Document Name", "Parties", "Agreement Date", "Effective Date",
-    "Expiration Date", "Renewal Term", "Governing Law", "Most Favored Nation",
-    "Non-Compete", "Exclusivity", "No-Solicit of Customers",
-    "No-Solicit of Employees", "Non-Disparagement",
-    "Termination for Convenience", "ROFR/ROFO/ROFN", "Change of Control",
-    "Anti-Assignment", "Revenue/Profit Sharing", "Price Restriction",
-    "Minimum Commitment", "Volume Restriction", "IP Ownership Assignment",
-    "Joint IP Ownership", "License Grant", "Non-Transferable License",
-    "Affiliate License-Licensor", "Affiliate License-Licensee",
-    "Unlimited/All-You-Can-Eat License", "Irrevocable or Perpetual License",
-    "Source Code Escrow", "Post-Termination Services", "Audit Rights",
-    "Uncapped Liability", "Cap on Liability", "Liquidated Damages",
-    "Warranty Duration", "Insurance", "Covenant Not to Sue",
-    "Third Party Beneficiary", "Other"
-]
-
-RISK_MAP = {
-    "Uncapped Liability": "CRITICAL", "Arbitration": "CRITICAL",
-    "IP Ownership Assignment": "CRITICAL", "Termination for Convenience": "CRITICAL",
-    "Limitation of liability": "CRITICAL", "Unilateral termination": "CRITICAL",
-    "Liquidated Damages": "CRITICAL",
-    "Non-Compete": "HIGH", "Exclusivity": "HIGH", "Change of Control": "HIGH",
-    "No-Solicit of Customers": "HIGH", "No-Solicit of Employees": "HIGH",
-    "Unilateral change": "HIGH", "Content removal": "HIGH", "Anti-Assignment": "HIGH",
-    "Governing Law": "MEDIUM", "Jurisdiction": "MEDIUM", "Choice of law": "MEDIUM",
-    "Price Restriction": "MEDIUM", "Minimum Commitment": "MEDIUM",
-    "Volume Restriction": "MEDIUM", "Non-Disparagement": "MEDIUM",
-    "Most Favored Nation": "MEDIUM", "Revenue/Profit Sharing": "MEDIUM",
-    "Warranty Duration": "MEDIUM",
-    "Document Name": "LOW", "Parties": "LOW", "Agreement Date": "LOW",
-    "Effective Date": "LOW", "Expiration Date": "LOW", "Renewal Term": "LOW",
-    "Joint IP Ownership": "LOW", "License Grant": "LOW",
-    "Non-Transferable License": "LOW", "Affiliate License-Licensor": "LOW",
-    "Affiliate License-Licensee": "LOW", "Unlimited/All-You-Can-Eat License": "LOW",
-    "Irrevocable or Perpetual License": "LOW", "Source Code Escrow": "LOW",
-    "Post-Termination Services": "LOW", "Audit Rights": "LOW",
-    "Cap on Liability": "LOW", "Insurance": "LOW",
-    "Covenant Not to Sue": "LOW", "Third Party Beneficiary": "LOW",
-    "Other": "LOW", "ROFR/ROFO/ROFN": "LOW", "Contract by using": "LOW",
-}
-
-DESC_MAP = {
-    "Limitation of liability": "Company limits or excludes liability for losses, data breaches, or service failures.",
-    "Unilateral termination": "Company can terminate your account at any time without reason.",
-    "Unilateral change": "Company can change terms at any time without your consent.",
-    "Content removal": "Company can delete your content without notice or justification.",
-    "Contract by using": "You are bound to the contract simply by using the service.",
-    "Choice of law": "Governing law may differ from your country, reducing your legal protections.",
-    "Jurisdiction": "Disputes must be resolved in a jurisdiction that may disadvantage you.",
-    "Arbitration": "Forces disputes to arbitration instead of court. You waive your right to sue.",
-    "Uncapped Liability": "No financial limit on damages the party may be liable for.",
-    "Cap on Liability": "Maximum financial liability is explicitly capped.",
-    "Non-Compete": "Restrictions on competing with the counter-party.",
-    "Exclusivity": "Obligation to deal exclusively with one party.",
-    "IP Ownership Assignment": "Intellectual property rights are transferred entirely.",
-    "Termination for Convenience": "Either party may terminate without cause or notice.",
-    "Governing Law": "Specifies which jurisdiction's laws apply.",
-    "Non-Disparagement": "Agreement not to speak negatively about the other party.",
-    "ROFR/ROFO/ROFN": "Right of First Refusal / Offer / Negotiation clause.",
-    "Change of Control": "Provisions triggered by ownership or control changes.",
-    "Anti-Assignment": "Restrictions on transferring contract rights to third parties.",
-    "Liquidated Damages": "Pre-determined damages amount for breach of contract.",
-    "Source Code Escrow": "Third-party holds source code for release under defined conditions.",
-    "Post-Termination Services": "Services to be provided after the contract ends.",
-    "Audit Rights": "Right to inspect records or verify compliance.",
-    "Warranty Duration": "Length of time warranties remain in effect.",
-    "Covenant Not to Sue": "Agreement not to bring legal action against a party.",
-    "Third Party Beneficiary": "Non-party who benefits from the contract terms.",
-    "Insurance": "Insurance coverage requirements.",
-    "Revenue/Profit Sharing": "Revenue or profit sharing arrangements between parties.",
-    "Price Restriction": "Restrictions on pricing or discounting.",
-    "Minimum Commitment": "Minimum purchase or usage commitment.",
-    "Volume Restriction": "Limits on volume of goods or services.",
-    "License Grant": "Permission to use intellectual property.",
-    "Non-Transferable License": "License that cannot be transferred to third parties.",
-    "Irrevocable or Perpetual License": "License that cannot be revoked or lasts indefinitely.",
-    "Unlimited/All-You-Can-Eat License": "License with no usage limits.",
-}
-
-RISK_WEIGHTS = {"CRITICAL": 40, "HIGH": 20, "MEDIUM": 10, "LOW": 3}
-
-# ─── Regex patterns (fallback) ───
-REGEX_PATTERNS = {
-    "Limitation of liability": [r"not liable", r"shall not be (liable|responsible)", r"in no event.*liable", r"limitation of liability", r"without warranty", r"disclaim"],
-    "Unilateral termination": [r"terminat.*at any time", r"suspend.*account.*without", r"we may (terminat|suspend|discontinu)", r"right to (terminat|suspend)"],
-    "Unilateral change": [r"sole discretion", r"reserves? the right to (modify|change|update|amend)", r"at any time.*without (prior )?notice", r"we may (modify|change|update)"],
-    "Content removal": [r"remove.*content.*without", r"right to remove", r"we may.*remove"],
-    "Contract by using": [r"by (using|accessing).*you agree", r"continued use.*constitutes? acceptance"],
-    "Choice of law": [r"governed by.*laws? of", r"shall be governed", r"laws of the state of"],
-    "Jurisdiction": [r"exclusive jurisdiction", r"courts? of.*(california|delaware|new york|ireland|england)", r"submit to.*jurisdiction"],
-    "Arbitration": [r"arbitrat", r"binding arbitration", r"waive.*right.*court", r"class action waiver"],
-    "Governing Law": [r"governed by", r"laws of", r"jurisdiction of"],
-    "Termination for Convenience": [r"terminat.*for convenience", r"terminat.*without cause", r"terminat.*at any time"],
-    "Non-Compete": [r"non-compete", r"shall not compete", r"competition"],
-    "Exclusivity": [r"exclusive", r"exclusivity"],
-    "IP Ownership Assignment": [r"assign.*intellectual property", r"ownership of.*ip", r"all rights.*assign"],
-    "Uncapped Liability": [r"unlimited liability", r"uncapped", r"no.*limit.*liability"],
-    "Cap on Liability": [r"cap on liability", r"maximum liability", r"liability.*shall not exceed"],
-    "Indemnification": [r"indemnif", r"hold harmless", r"defend"],
-    "Confidentiality": [r"confidential", r"non-disclosure", r"nda"],
-    "Force Majeure": [r"force majeure", r"act of god", r"beyond.*control"],
-    "Penalties": [r"penalt", r"late fee", r"default charge", r"interest on overdue"],
-}
-
-# ─── Model Loading ───
-cuad_tokenizer = None
-cuad_model = None
-_HAS_TORCH = False
-
-try:
-    import torch
-    from transformers import AutoTokenizer, AutoModelForSequenceClassification
-    from peft import PeftModel
-    _HAS_TORCH = True
-except Exception:
-    pass
-
-def load_model():
-    global cuad_tokenizer, cuad_model, classifier
-    if not _HAS_TORCH:
-        print("[ClauseGuard] PyTorch not available")
-        return
-    try:
-        base = "nlpaueb/legal-bert-base-uncased"
-        adapter = "Mokshith31/legalbert-contract-clause-classification"
-        print(f"[ClauseGuard] Loading CUAD classifier: {adapter}")
-        cuad_tokenizer = AutoTokenizer.from_pretrained(base)
-        base_model = AutoModelForSequenceClassification.from_pretrained(
-            base, num_labels=41, ignore_mismatched_sizes=True
-        )
-        cuad_model = PeftModel.from_pretrained(base_model, adapter)
-        cuad_model.eval()
-        print("[ClauseGuard] CUAD model loaded successfully")
-    except Exception as e:
-        print(f"[ClauseGuard] CUAD model load failed: {e}")
-        cuad_tokenizer = None
-        cuad_model = None
+MAX_TEXT_LENGTH = int(os.environ.get("MAX_TEXT_LENGTH", "100000"))  # 100KB default
+
+# ─── Rate Limiting ───
+_rate_limits = {}  # ip -> (count, window_start)
+RATE_LIMIT_REQUESTS = 30
+RATE_LIMIT_WINDOW = 60  # seconds
+
+def _check_rate_limit(client_ip: str) -> bool:
+    now = time.time()
+    if client_ip in _rate_limits:
+        count, window_start = _rate_limits[client_ip]
+        if now - window_start > RATE_LIMIT_WINDOW:
+            _rate_limits[client_ip] = (1, now)
+            return True
+        if count >= RATE_LIMIT_REQUESTS:
+            return False
+        _rate_limits[client_ip] = (count + 1, window_start)
+        return True
+    _rate_limits[client_ip] = (1, now)
+    return True
 
 # ─── Supabase helper ───
 async def supabase_insert(table: str, data: dict):
     if not SUPABASE_URL or not SUPABASE_SERVICE_KEY:
         return
-    async with httpx.AsyncClient() as client:
-        await client.post(
-            f"{SUPABASE_URL}/rest/v1/{table}",
-            json=data,
-            headers={"apikey": SUPABASE_SERVICE_KEY, "Authorization": f"Bearer {SUPABASE_SERVICE_KEY}",
-                      "Content-Type": "application/json", "Prefer": "return=minimal"},
-        )
+    try:
+        async with httpx.AsyncClient() as client:
+            await client.post(
+                f"{SUPABASE_URL}/rest/v1/{table}",
+                json=data,
+                headers={
+                    "apikey": SUPABASE_SERVICE_KEY,
+                    "Authorization": f"Bearer {SUPABASE_SERVICE_KEY}",
+                    "Content-Type": "application/json",
+                    "Prefer": "return=minimal",
+                },
+                timeout=10.0,
+            )
+    except Exception:
+        pass
 
 async def supabase_query(table: str, params: dict, headers_extra: dict = {}):
     if not SUPABASE_URL or not SUPABASE_SERVICE_KEY:
         return []
-    async with httpx.AsyncClient() as client:
-        resp = await client.get(
-            f"{SUPABASE_URL}/rest/v1/{table}",
-            params=params,
-            headers={"apikey": SUPABASE_SERVICE_KEY, "Authorization": f"Bearer {SUPABASE_SERVICE_KEY}", **headers_extra},
-        )
-        return resp.json() if resp.status_code == 200 else []
-
-# ─── Clause Processing ───
-def split_clauses(text):
-    text = re.sub(r'\n{3,}', '\n\n', text.strip())
-    parts = re.split(r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n\n)(?=\d+[.)]\s|\([a-z]\)\s|[A-Z][A-Z\s]{2,})', text)
-    return [p.strip() for p in parts if len(p.strip()) > 30]
-
-def classify_regex(text):
-    text_lower = text.lower()
-    results = []
-    seen = set()
-    for label, patterns in REGEX_PATTERNS.items():
-        for pat in patterns:
-            if re.search(pat, text_lower):
-                if label not in seen:
-                    risk = RISK_MAP.get(label, "MEDIUM")
-                    results.append({
-                        "label": label,
-                        "confidence": 0.7,
-                        "risk": risk,
-                        "description": DESC_MAP.get(label, label),
-                    })
-                    seen.add(label)
-                break
-    return results
-
-def classify_cuad(clause_text):
-    if cuad_model is None or cuad_tokenizer is None:
-        return classify_regex(clause_text)
     try:
-        inputs = cuad_tokenizer(clause_text, return_tensors="pt", truncation=True, max_length=256, padding=True)
-        with torch.no_grad():
-            logits = cuad_model(**inputs).logits
-        probs = torch.softmax(logits, dim=-1)[0]
-        threshold = 0.15
-        results = []
-        for i, prob in enumerate(probs):
-            if prob > threshold and i < len(CUAD_LABELS):
-                label = CUAD_LABELS[i]
-                results.append({
-                    "label": label,
-                    "confidence": round(float(prob), 3),
-                    "risk": RISK_MAP.get(label, "LOW"),
-                    "description": DESC_MAP.get(label, label),
-                })
-        results.sort(key=lambda x: x["confidence"], reverse=True)
-        if not results:
-            top_idx = int(probs.argmax())
-            label = CUAD_LABELS[top_idx] if top_idx < len(CUAD_LABELS) else "Other"
-            results.append({
-                "label": label,
-                "confidence": round(float(probs[top_idx]), 3),
-                "risk": RISK_MAP.get(label, "LOW"),
-                "description": DESC_MAP.get(label, label),
-            })
-        return results
+        async with httpx.AsyncClient() as client:
+            resp = await client.get(
+                f"{SUPABASE_URL}/rest/v1/{table}",
+                params=params,
+                headers={
+                    "apikey": SUPABASE_SERVICE_KEY,
+                    "Authorization": f"Bearer {SUPABASE_SERVICE_KEY}",
+                    **headers_extra,
+                },
+                timeout=10.0,
+            )
+            return resp.json() if resp.status_code == 200 else []
     except Exception:
-        return classify_regex(clause_text)
-
-# ─── NER ───
-def extract_entities(text):
-    entities = []
-    # Dates
-    for pat, etype in [
-        (r'\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},?\s+\d{4}\b', "DATE"),
-        (r'\b\d{1,2}/\d{1,2}/\d{2,4}\b', "DATE"),
-        (r'\b\d{1,2}-\d{1,2}-\d{2,4}\b', "DATE"),
-        (r'\b(?:Effective|Commencement|Expiration|Termination)\s+Date\b', "DATE_REF"),
-    ]:
-        for m in re.finditer(pat, text, re.IGNORECASE):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    # Money
-    for pat, etype in [
-        (r'\$\d{1,3}(?:,\d{3})*(?:\.\d{2})?(?:\s*(?:million|billion|thousand|M|B|K))?', "MONEY"),
-        (r'\b\d{1,3}(?:,\d{3})*(?:\.\d{2})?\s*(?:USD|EUR|GBP|dollars|euros)', "MONEY"),
-    ]:
-        for m in re.finditer(pat, text, re.IGNORECASE):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    # Parties
-    for pat, etype in [
-        (r'\b[A-Z][A-Za-z0-9\s&]+(?:Inc\.|LLC|Ltd\.|Limited|Corp\.|Corporation|PLC|GmbH|AG|S\.A\.|B\.V\.)\b', "PARTY"),
-        (r'\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client)\b', "PARTY_ROLE"),
-    ]:
-        for m in re.finditer(pat, text):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    # Jurisdictions
-    for pat, etype in [
-        (r'\b(?:State|Laws?) of [A-Z][a-zA-Z\s]+', "JURISDICTION"),
-        (r'\b(?:California|Delaware|New York|Texas|Florida|England|Ireland|Germany|France|Singapore|Hong Kong)\b', "JURISDICTION"),
-    ]:
-        for m in re.finditer(pat, text, re.IGNORECASE):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    # Defined Terms
-    for pat, etype in [
-        (r'"([A-Z][A-Z\s]+)"', "DEFINED_TERM"),
-        (r'\(([A-Z][A-Z\s]+)\)', "DEFINED_TERM"),
-    ]:
-        for m in re.finditer(pat, text):
-            entities.append({"text": m.group(1), "type": etype, "start": m.start(), "end": m.end()})
-    # Deduplicate
-    entities.sort(key=lambda x: (x["start"], -(x["end"] - x["start"])))
-    filtered = []
-    last_end = -1
-    for e in entities:
-        if e["start"] >= last_end:
-            filtered.append(e)
-            last_end = e["end"]
-    return filtered
-
-# ─── Contradictions ───
-CONTRADICTION_PAIRS = [
-    (["Uncapped Liability", "unlimited liability"], ["Cap on Liability", "cap on liability"],
-     "Liability cannot be both uncapped and capped simultaneously."),
-    (["Governing Law"], ["Governing Law"],
-     "Multiple governing law provisions detected — verify consistency."),
-    (["Termination for Convenience", "terminat.*convenience"], ["Fixed Term", "fixed term"],
-     "Contract has both fixed term and termination for convenience — review carefully."),
-    (["IP Ownership Assignment", "assign.*ip"], ["Joint IP Ownership", "joint ownership"],
-     "IP cannot be both fully assigned and jointly owned."),
-]
-
-def detect_contradictions(clause_results):
-    contradictions = []
-    labels_found = set()
-    for cr in clause_results:
-        labels_found.add(cr["label"])
-    for group_a, group_b, explanation in CONTRADICTION_PAIRS:
-        found_a = any(l in labels_found for l in group_a)
-        found_b = any(l in labels_found for l in group_b)
-        if found_a and found_b:
-            contradictions.append({"type": "CONTRADICTION", "explanation": explanation, "severity": "HIGH", "clauses": list(set(group_a + group_b))})
-    for cc in ["Governing Law", "Termination for Convenience", "Limitation of liability", "Arbitration"]:
-        if cc not in labels_found:
-            contradictions.append({"type": "MISSING", "explanation": f"Critical clause '{cc}' not detected.", "severity": "MEDIUM", "clauses": [cc]})
-    return contradictions
-
-# ─── Risk Scoring ───
-def compute_risk_score(clause_results, total_clauses):
-    sev_counts = {"CRITICAL": 0, "HIGH": 0, "MEDIUM": 0, "LOW": 0}
-    for cr in clause_results:
-        sev = cr.get("risk", "LOW")
-        sev_counts[sev] += 1
-    if total_clauses == 0:
-        return 0, "A", sev_counts
-    weighted = sum(sev_counts[s] * RISK_WEIGHTS[s] for s in sev_counts)
-    risk = min(100, round(weighted / max(1, total_clauses) * 10))
-    if risk >= 70: grade = "F"
-    elif risk >= 50: grade = "D"
-    elif risk >= 30: grade = "C"
-    elif risk >= 15: grade = "B"
-    else: grade = "A"
-    return risk, grade, sev_counts
-
-# ─── Obligations ───
-OBLIGATION_PATTERNS = {
-    "monetary": [r"(?:shall|must|will|agrees? to)\s+pay\s+(?:\$?[\d,]+)", r"(?:fee|payment|compensation|reimburs(?:e|ement))\s+of\s+(?:\$?[\d,]+)", r"(?:shall|must|will)\s+remit\s+(?:\$?[\d,]+)", r"(?:annual|monthly|quarterly)\s+(?:fee|payment)\s+of", r"(?:liquidated damages|penalty)\s+of\s+(?:\$?[\d,]+)"],
-    "compliance": [r"(?:shall|must|will)\s+comply\s+with", r"(?:shall|must|will)\s+adhere\s+to", r"(?:shall|must|will)\s+conform\s+to", r"(?:GDPR|CCPA|HIPAA|SOX|PCI-DSS|ISO\s+\d+)", r"(?:confidential|privacy|data protection)", r"(?:shall|must|will)\s+maintain\s+(?:insurance|coverage|bond)"],
-    "reporting": [r"(?:shall|must|will)\s+report", r"(?:shall|must|will)\s+provide\s+(?:regular|monthly|quarterly|annual)\s+(?:reports?|updates?|status)", r"(?:shall|must|will)\s+notify", r"(?:shall|must|will)\s+inform"],
-    "delivery": [r"(?:shall|must|will)\s+deliver", r"(?:shall|must|will)\s+provide", r"(?:shall|must|will)\s+furnish", r"(?:shall|must|will)\s+supply", r"(?:shall|must|will)\s+submit"],
-    "termination": [r"(?:shall|must|will)\s+return", r"(?:shall|must|will)\s+destroy", r"(?:shall|must|will)\s+cease", r"(?:upon|after)\s+termination"],
-}
-
-def extract_obligations(text):
-    sentences = re.split(r'(?<=[.!?])\s+(?=[A-Z])', text)
-    obligations = []
-    for sentence in sentences:
-        sentence = sentence.strip()
-        if len(sentence) < 30:
-            continue
-        found_types = set()
-        for otype, patterns in OBLIGATION_PATTERNS.items():
-            for pat in patterns:
-                if re.search(pat, sentence, re.IGNORECASE):
-                    found_types.add(otype)
-                    break
-        if not found_types:
-            continue
-        party = "Unknown"
-        for pp in [r'\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client)\b', r'\b[A-Z][A-Za-z0-9\s&]+(?:Inc\.|LLC|Ltd\.|Limited|Corp\.|Corporation|PLC|GmbH|AG|S\.A\.|B\.V\.)\b']:
-            m = re.search(pp, sentence)
-            if m:
-                party = m.group(0)
-                break
-        deadline = "Not specified"
-        for pat, ptype in [
-            (r"within\s+(\d+)\s+(day|week|month|year)s?", "relative"),
-            (r"no\s+later\s+than\s+(\d+)\s+(day|week|month|year)s?", "relative"),
-            (r"within\s+(\d+)\s+business\s+days?", "business_days"),
-            (r"by\s+([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", "absolute"),
-            (r"on\s+or\s+before\s+([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", "absolute"),
-        ]:
-            m = re.search(pat, sentence, re.IGNORECASE)
-            if m:
-                deadline = m.group(0)
-                break
-        for otype in found_types:
-            obligations.append({"type": otype, "party": party, "description": sentence[:250] + ("..." if len(sentence) > 250 else ""), "deadline": deadline})
-    return obligations
-
-# ─── Compliance ───
-REGULATIONS = {
-    "GDPR": {
-        "description": "EU General Data Protection Regulation (Regulation 2016/679)",
-        "requirements": {
-            "lawful_basis": {"keywords": ["lawful basis", "legal basis", "legitimate interest", "consent", "performance of contract", "legal obligation"], "description": "Must specify lawful basis for data processing (Art. 6)", "severity": "HIGH"},
-            "data_subject_rights": {"keywords": ["right to access", "right to erasure", "right to be forgotten", "data portability", "rectification", "object to processing"], "description": "Must acknowledge data subject rights (Arts. 15-22)", "severity": "HIGH"},
-            "data_breach_notification": {"keywords": ["data breach", "breach notification", "notify supervisory authority", "72 hours"], "description": "Must include data breach notification obligations (Art. 33)", "severity": "MEDIUM"},
-            "cross_border_transfer": {"keywords": ["standard contractual clauses", "SCCs", "adequacy decision", "transfer mechanism", "third country"], "description": "Must specify transfer safeguards for cross-border data (Arts. 44-49)", "severity": "HIGH"},
-        },
-    },
-    "CCPA": {
-        "description": "California Consumer Privacy Act (Cal. Civ. Code § 1798.100 et seq.)",
-        "requirements": {
-            "consumer_rights": {"keywords": ["right to know", "right to delete", "right to opt out", "right to non-discrimination", "consumer rights"], "description": "Must acknowledge California consumer rights", "severity": "HIGH"},
-            "data_categories": {"keywords": ["categories of personal information", "personal information categories", "identifiers", "commercial information"], "description": "Must disclose categories of personal information collected", "severity": "HIGH"},
-            "sale_of_data": {"keywords": ["do not sell my personal information", "opt-out of sale", "sale of personal information"], "description": "Must provide opt-out mechanism for data sales", "severity": "HIGH"},
-        },
-    },
-    "SOX": {
-        "description": "Sarbanes-Oxley Act (US, 2002)",
-        "requirements": {
-            "internal_controls": {"keywords": ["internal controls", "internal control over financial reporting", "ICFR"], "description": "Must reference internal controls over financial reporting (§ 404)", "severity": "HIGH"},
-            "whistleblower": {"keywords": ["whistleblower", "anonymous reporting", "reporting hotline", "retaliation"], "description": "Should protect whistleblower provisions (§ 806)", "severity": "HIGH"},
-            "document_retention": {"keywords": ["document retention", "record retention", "retention policy", "preserve records"], "description": "Must include document retention obligations (§ 802)", "severity": "HIGH"},
-        },
-    },
-    "HIPAA": {
-        "description": "Health Insurance Portability and Accountability Act (US, 1996)",
-        "requirements": {
-            "phi_protection": {"keywords": ["protected health information", "PHI", "health information", "ePHI"], "description": "Must protect PHI and limit uses/disclosures", "severity": "CRITICAL"},
-            "security_safeguards": {"keywords": ["administrative safeguards", "technical safeguards", "physical safeguards", "encryption", "access controls"], "description": "Must implement security safeguards (§ 164.308-312)", "severity": "HIGH"},
-            "breach_notification": {"keywords": ["breach notification", "notification of breach", "unauthorized access"], "description": "Must include breach notification obligations (§ 164.400-414)", "severity": "HIGH"},
-        },
-    },
-    "FINRA": {
-        "description": "Financial Industry Regulatory Authority (US)",
-        "requirements": {
-            "recordkeeping": {"keywords": ["recordkeeping", "books and records", "retain records", "SEC Rule 17a-4"], "description": "Must comply with recordkeeping rules (FINRA Rule 4511)", "severity": "HIGH"},
-            "anti_money_laundering": {"keywords": ["anti-money laundering", "AML", "suspicious activity", "SAR", "OFAC"], "description": "Must reference AML compliance (FINRA Rule 3310)", "severity": "HIGH"},
-            "privacy": {"keywords": ["privacy policy", "customer information", "Regulation S-P", "nonpublic personal information"], "description": "Must protect customer information (Regulation S-P)", "severity": "HIGH"},
-        },
-    },
-}
-
-def check_compliance(text):
-    text_lower = text.lower()
-    results = {}
-    for reg_name, reg_data in REGULATIONS.items():
-        checks = []
-        for req_name, req_data in reg_data["requirements"].items():
-            matched = False
-            matched_keywords = []
-            for kw in req_data["keywords"]:
-                if kw.lower() in text_lower:
-                    matched = True
-                    matched_keywords.append(kw)
-            checks.append({"requirement": req_name, "description": req_data["description"], "severity": req_data["severity"], "status": "PASS" if matched else "MISSING", "matched_keywords": matched_keywords})
-        passed = sum(1 for c in checks if c["status"] == "PASS")
-        total = len(checks)
-        compliance_rate = round(passed / total * 100) if total > 0 else 0
-        results[reg_name] = {"description": reg_data["description"], "compliance_rate": compliance_rate, "checks": checks, "overall_status": "COMPLIANT" if compliance_rate >= 80 else "PARTIAL" if compliance_rate >= 40 else "NON-COMPLIANT"}
-    return results
-
-# ─── Comparison ───
-from difflib import SequenceMatcher
-
-def _normalize(text):
-    text = text.lower()
-    text = re.sub(r'[^a-z0-9\s]', ' ', text)
-    text = re.sub(r'\s+', ' ', text).strip()
-    return text
-
-def _clause_type(text):
-    text_lower = text.lower()
-    type_keywords = {
-        "governing law": ["govern", "law", "jurisdiction"],
-        "termination": ["terminat", "cancel", "end"],
-        "indemnification": ["indemnif", "hold harmless"],
-        "confidentiality": ["confidential", "non-disclosure"],
-        "liability": ["liability", "liable", "damages"],
-        "payment": ["payment", "fee", "price", "compensat"],
-        "intellectual property": ["intellectual", "ip", "copyright", "patent"],
-        "warranty": ["warrant", "guarantee"],
-        "force majeure": ["force majeure", "act of god"],
-        "arbitration": ["arbitrat", "mediation"],
-        "assignment": ["assign", "transfer"],
-        "non-compete": ["compete", "competition"],
-        "renewal": ["renew", "extend"],
-    }
-    for ctype, keywords in type_keywords.items():
-        if any(kw in text_lower for kw in keywords):
-            return ctype
-    return "general"
-
-def compare_contracts(text_a, text_b):
-    clauses_a = split_clauses(text_a)
-    clauses_b = split_clauses(text_b)
-    matched_a = set()
-    matched_b = set()
-    modified = []
-    for i, ca in enumerate(clauses_a):
-        best_sim, best_j = 0, -1
-        for j, cb in enumerate(clauses_b):
-            if j in matched_b:
-                continue
-            sim = SequenceMatcher(None, _normalize(ca), _normalize(cb)).ratio()
-            if sim > best_sim:
-                best_sim = sim
-                best_j = j
-        if best_sim >= 0.75:
-            matched_a.add(i)
-            matched_b.add(best_j)
-            if best_sim < 0.95:
-                modified.append({"type": "modified", "similarity": round(best_sim, 3), "clause_a": ca[:200], "clause_b": clauses_b[best_j][:200], "clause_type": _clause_type(ca)})
-        elif best_sim >= 0.45:
-            modified.append({"type": "partial", "similarity": round(best_sim, 3), "clause_a": ca[:200], "clause_b": clauses_b[best_j][:200] if best_j >= 0 else "", "clause_type": _clause_type(ca)})
-    removed = [clauses_a[i] for i in range(len(clauses_a)) if i not in matched_a]
-    added = [clauses_b[j] for j in range(len(clauses_b)) if j not in matched_b]
-    total_pairs = max(len(clauses_a), len(clauses_b))
-    alignment = len(matched_a) / total_pairs if total_pairs > 0 else 0.0
-    risk_keywords = ["unlimited", "unilateral", "waive", "arbitration", "indemnif", "not liable", "no warranty", "sole discretion"]
-    risk_a = sum(1 for kw in risk_keywords if kw in text_a.lower())
-    risk_b = sum(1 for kw in risk_keywords if kw in text_b.lower())
-    if risk_a > risk_b + 2:
-        risk_delta, risk_winner = "Contract A is significantly riskier", "B"
-    elif risk_b > risk_a + 2:
-        risk_delta, risk_winner = "Contract B is significantly riskier", "A"
-    else:
-        risk_delta, risk_winner = "Similar risk profiles", "tie"
-    return {
-        "alignment_score": round(alignment, 3),
-        "contract_a_clauses": len(clauses_a), "contract_b_clauses": len(clauses_b),
-        "added_clauses": [{"text": c[:200], "type": _clause_type(c)} for c in added[:50]],
-        "removed_clauses": [{"text": c[:200], "type": _clause_type(c)} for c in removed[:50]],
-        "modified_clauses": modified[:50],
-        "risk_delta": risk_delta, "risk_winner": risk_winner,
-        "type_map_a": {k: len(v) for k, v in defaultdict(list, [("general", [])]).items()},
-        "type_map_b": {k: len(v) for k, v in defaultdict(list, [("general", [])]).items()},
-    }
+        return []
 
-# ─── Models ───
+# ─── Request/Response Models ───
 class AnalyzeRequest(BaseModel):
-    text: str = Field(..., min_length=50)
+    text: Optional[str] = Field(None, min_length=50)
+    clauses: Optional[list] = None  # FIXED: accept clauses array from extension
     source_url: Optional[str] = None
 
 class AnalyzeResponse(BaseModel):
@@ -575,62 +150,128 @@ class ExplainResponse(BaseModel):
 # ─── App ───
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    load_model()
+    # Models are loaded when app.py is imported
     yield
 
-app = FastAPI(title="ClauseGuard API", version="2.0.0", lifespan=lifespan)
+app = FastAPI(title="ClauseGuard API", version="3.0.0", lifespan=lifespan)
 
+# FIXED: No wildcard CORS
+ALLOWED_ORIGINS = [
+    "https://clauseguardweb.netlify.app",
+    "http://localhost:3000",
+    "http://localhost:3001",
+]
+# Allow chrome extensions
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["https://clauseguardweb.netlify.app", "https://clauseguardweb.netlify.app", "chrome-extension://*", "http://localhost:3000", "*"],
-    allow_credentials=True, allow_methods=["*"], allow_headers=["*"],
+    allow_origins=ALLOWED_ORIGINS,
+    allow_origin_regex=r"^chrome-extension://.*$",
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 @app.get("/health")
 async def health():
-    return {"status": "ok", "model": "ml" if cuad_model else "regex", "version": "2.0.0"}
+    model_status = "ml" if _SHARED_MODULES and cuad_model else "regex"
+    return {
+        "status": "ok",
+        "model": model_status,
+        "version": "3.0.0",
+        "shared_modules": _SHARED_MODULES,
+    }
 
 @app.post("/api/analyze", response_model=AnalyzeResponse)
-async def analyze(req: AnalyzeRequest, user: Optional[dict] = Depends(get_current_user)):
+async def analyze(req: AnalyzeRequest, request: Request, user: Optional[dict] = Depends(get_current_user)):
+    # Rate limiting
+    client_ip = request.client.host if request.client else "unknown"
+    if not _check_rate_limit(client_ip):
+        raise HTTPException(status_code=429, detail="Rate limit exceeded. Try again in 60 seconds.")
+
+    # FIXED: Accept either text or clauses from extension
+    text = req.text
+    if not text and req.clauses:
+        text = "\n\n".join(req.clauses) if isinstance(req.clauses, list) else str(req.clauses)
+
+    if not text or len(text.strip()) < 50:
+        raise HTTPException(status_code=400, detail="Text too short (minimum 50 characters)")
+
+    # Max length check
+    if len(text) > MAX_TEXT_LENGTH:
+        raise HTTPException(status_code=400, detail=f"Text too long (maximum {MAX_TEXT_LENGTH} characters)")
+
     start = time.time()
-    clauses = split_clauses(req.text)
+    clauses = split_clauses(text)
     if not clauses:
         raise HTTPException(status_code=400, detail="No clauses detected in document")
-    
+
     clause_results = []
     for clause in clauses:
         predictions = classify_cuad(clause)
         if predictions:
             for pred in predictions:
-                clause_results.append({"text": clause, "label": pred["label"], "confidence": pred["confidence"], "risk": pred["risk"], "description": pred["description"]})
-    
-    entities = extract_entities(req.text)
-    contradictions = detect_contradictions(clause_results)
+                clause_results.append({
+                    "text": clause,
+                    "label": pred["label"],
+                    "confidence": pred["confidence"],
+                    "risk": pred["risk"],
+                    "description": pred["description"],
+                    "source": pred.get("source", "unknown"),
+                })
+
+    entities = extract_entities(text)
+    contradictions = detect_contradictions(clause_results, text)
     risk, grade, sev_counts = compute_risk_score(clause_results, len(clauses))
-    obligations = extract_obligations(req.text)
-    compliance = check_compliance(req.text)
+    obligations = extract_obligations(text)
+    compliance = check_compliance(text)
     latency = int((time.time() - start) * 1000)
-    
-    results_for_db = [{"text": cr["text"], "categories": [{"name": cr["label"], "severity": cr["risk"], "confidence": cr["confidence"], "description": cr["description"]}]} for cr in clause_results]
-    
+
+    results_for_db = []
+    for cr in clause_results:
+        results_for_db.append({
+            "text": cr["text"],
+            "categories": [{
+                "name": cr["label"],
+                "severity": cr["risk"],
+                "confidence": cr["confidence"],
+                "description": cr["description"],
+            }],
+        })
+
     if user:
         await supabase_insert("analyses", {
-            "user_id": user["id"], "source_url": req.source_url, "total_clauses": len(clauses),
-            "flagged_count": len(set(cr["text"] for cr in clause_results)), "risk_score": risk, "grade": grade,
-            "clauses": results_for_db, "entities": entities, "contradictions": contradictions,
-            "obligations": obligations, "compliance": compliance,
+            "user_id": user["id"],
+            "source_url": req.source_url,
+            "total_clauses": len(clauses),
+            "flagged_count": len(set(cr["text"] for cr in clause_results)),
+            "risk_score": risk,
+            "grade": grade,
+            "clauses": results_for_db,
+            "entities": entities,
+            "contradictions": contradictions,
+            "obligations": obligations,
+            "compliance": compliance,
         })
-    
+
     return AnalyzeResponse(
-        risk_score=risk, grade=grade, total_clauses=len(clauses),
+        risk_score=risk,
+        grade=grade,
+        total_clauses=len(clauses),
         flagged_count=len(set(cr["text"] for cr in clause_results)),
-        results=results_for_db, entities=entities, contradictions=contradictions,
-        obligations=obligations, compliance=compliance,
-        model="ml" if cuad_model else "regex", latency_ms=latency,
+        results=results_for_db,
+        entities=entities,
+        contradictions=contradictions,
+        obligations=obligations,
+        compliance=compliance,
+        model="ml" if cuad_model else "regex",
+        latency_ms=latency,
     )
 
 @app.post("/api/compare")
-async def compare(req: CompareRequest):
+async def compare(req: CompareRequest, request: Request):
+    client_ip = request.client.host if request.client else "unknown"
+    if not _check_rate_limit(client_ip):
+        raise HTTPException(status_code=429, detail="Rate limit exceeded.")
     result = compare_contracts(req.text_a, req.text_b)
     return result
 
@@ -639,11 +280,26 @@ async def explain(req: ExplainRequest, user: dict = Depends(require_auth)):
     desc = DESC_MAP.get(req.category, "Unknown category.")
     legal = "Consult local consumer protection laws."
     recommendation = "Review this clause carefully. Consider negotiating or seeking legal advice before agreeing."
+
     if SAULLM_ENDPOINT and HF_API_TOKEN:
         try:
-            prompt = f"You are a consumer protection legal analyst. Analyze this clause and explain why it may be unfair.\n\nClause: \"{req.clause}\"\nCategory: {req.category}\n\nProvide:\n1. A plain-English explanation\n2. The specific legal basis\n3. A practical recommendation\n\nBe concise. 3-4 sentences per section."
+            prompt = (
+                f"You are a consumer protection legal analyst. Analyze this contract clause "
+                f"and explain why it may be unfair or risky.\n\n"
+                f"Clause: \"{req.clause}\"\n"
+                f"Category: {req.category}\n\n"
+                f"Provide:\n"
+                f"1. A plain-English explanation of what this clause means\n"
+                f"2. The specific legal basis or consumer protection concern\n"
+                f"3. A practical recommendation\n\n"
+                f"Be concise. 3-4 sentences per section."
+            )
             async with httpx.AsyncClient(timeout=30.0) as client:
-                resp = await client.post(SAULLM_ENDPOINT, json={"inputs": prompt, "parameters": {"max_new_tokens": 300, "temperature": 0.3}}, headers={"Authorization": f"Bearer {HF_API_TOKEN}"})
+                resp = await client.post(
+                    SAULLM_ENDPOINT,
+                    json={"inputs": prompt, "parameters": {"max_new_tokens": 300, "temperature": 0.3}},
+                    headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
+                )
                 if resp.status_code == 200:
                     output = resp.json()
                     generated = output[0]["generated_text"] if isinstance(output, list) else output.get("generated_text", "")
@@ -654,12 +310,28 @@ async def explain(req: ExplainRequest, user: dict = Depends(require_auth)):
                         recommendation = parts[2] if len(parts) > 2 else recommendation
         except Exception:
             pass
-    return ExplainResponse(clause=req.clause, category=req.category, explanation=desc, legal_basis=legal, recommendation=recommendation)
+
+    return ExplainResponse(
+        clause=req.clause,
+        category=req.category,
+        explanation=desc,
+        legal_basis=legal,
+        recommendation=recommendation,
+    )
 
 @app.get("/api/history")
 async def history(user: dict = Depends(require_auth), limit: int = 20, offset: int = 0):
     limit = min(limit, 100)
-    data = await supabase_query("analyses", {"user_id": f"eq.{user['id']}", "select": "*", "order": "created_at.desc", "limit": str(limit), "offset": str(offset)})
+    data = await supabase_query(
+        "analyses",
+        {
+            "user_id": f"eq.{user['id']}",
+            "select": "*",
+            "order": "created_at.desc",
+            "limit": str(limit),
+            "offset": str(offset),
+        },
+    )
     return {"analyses": data, "limit": limit, "offset": offset}
 
 if __name__ == "__main__":

api/requirements.txt

@@ -1,10 +1,10 @@
-fastapi==0.136.0
-uvicorn[standard]==0.46.0
-pydantic==2.13.3
-transformers==5.6.1
-optimum[onnxruntime]>=1.24.0
+fastapi>=0.136.0
+uvicorn[standard]>=0.46.0
+pydantic>=2.13.3
+transformers>=5.6.1
 numpy>=2.0.0
 python-jose[cryptography]>=3.3.0
 httpx>=0.28.0
 peft>=0.15.0
 torch>=2.5.0
+sentence-transformers>=3.0.0

app.py

@@ -1,21 +1,26 @@
 """
-ClauseGuard — World's Best Legal Contract Analysis Tool
-════════════════════════════════════════════════════════
-Features:
-  • 41 CUAD clause categories via fine-tuned Legal-BERT
-  • 4-tier risk scoring (Critical / High / Medium / Low)
-  • Legal NER: parties, dates, monetary values, jurisdictions, defined terms
-  • NLI contradiction & missing-clause detection
-  • Contract comparison engine (diff between 2 contracts)
-  • Obligation tracker (monetary, compliance, reporting, delivery)
-  • Compliance checker (GDPR, CCPA, SOX, HIPAA, FINRA)
-  • PDF / DOCX / TXT parsing
-  • Professional 3-panel Gradio UI
-  • JSON & CSV export
+ClauseGuard — World's Best Legal Contract Analysis Tool (v3.0)
+═══════════════════════════════════════════════════════════════
+Fixes in v3.0:
+  • Fixed CUAD label mapping (added missing index 6: "Notice Period to Terminate Renewal")
+  • Switched from softmax → sigmoid for proper multi-label classification
+  • Per-class optimized thresholds instead of flat 0.15
+  • Structure-aware clause splitting (respects section numbering)
+  • Real NLI contradiction detection via cross-encoder model
+  • ML-based Legal NER (matterstack/legal-bert-ner) with regex fallback
+  • Semantic compliance checking with negation handling
+  • Improved obligation extraction with false-positive filtering
+  • LLM-powered clause explanations (via HF Inference API)
+  • Prediction caching (LRU) for performance
+  • Per-session temp files (no collision)
+  • Model health reporting to user
+  • Document structure parsing
 
 Models:
   • Clause classifier: Mokshith31/legalbert-contract-clause-classification
     (LoRA adapter on nlpaueb/legal-bert-base-uncased, 41 CUAD classes)
+  • Legal NER: matterstack/legal-bert-ner (token classification)
+  • NLI: cross-encoder/nli-deberta-v3-base (contradiction detection)
 """
 
 import os
@@ -23,8 +28,12 @@ import re
 import json
 import csv
 import io
+import uuid
+import tempfile
+import hashlib
 from collections import defaultdict
 from datetime import datetime
+from functools import lru_cache
 
 import gradio as gr
 import numpy as np
@@ -43,13 +52,20 @@ except Exception:
     _HAS_DOCX = False
 
 # ── PyTorch / Transformers (soft-fail) ────────────────────────────────
+_HAS_TORCH = False
+_HAS_NER_MODEL = False
+_HAS_NLI_MODEL = False
+
 try:
     import torch
-    from transformers import AutoTokenizer, AutoModelForSequenceClassification
+    from transformers import (
+        AutoTokenizer, AutoModelForSequenceClassification,
+        AutoModelForTokenClassification, pipeline
+    )
     from peft import PeftModel
     _HAS_TORCH = True
 except Exception:
-    _HAS_TORCH = False
+    pass
 
 # ── Import submodules ───────────────────────────────────────────────
 from compare import compare_contracts, render_comparison_html
@@ -57,24 +73,51 @@ from obligations import extract_obligations, render_obligations_html
 from compliance import check_compliance, render_compliance_html
 
 # ═══════════════════════════════════════════════════════════════════════
-# 1. CONFIGURATION
+# 1. CONFIGURATION — FIXED label mapping (41 labels, index 6 restored)
 # ═══════════════════════════════════════════════════════════════════════
 
 CUAD_LABELS = [
-    "Document Name", "Parties", "Agreement Date", "Effective Date",
-    "Expiration Date", "Renewal Term", "Governing Law", "Most Favored Nation",
-    "Non-Compete", "Exclusivity", "No-Solicit of Customers",
-    "No-Solicit of Employees", "Non-Disparagement",
-    "Termination for Convenience", "ROFR/ROFO/ROFN", "Change of Control",
-    "Anti-Assignment", "Revenue/Profit Sharing", "Price Restriction",
-    "Minimum Commitment", "Volume Restriction", "IP Ownership Assignment",
-    "Joint IP Ownership", "License Grant", "Non-Transferable License",
-    "Affiliate License-Licensor", "Affiliate License-Licensee",
-    "Unlimited/All-You-Can-Eat License", "Irrevocable or Perpetual License",
-    "Source Code Escrow", "Post-Termination Services", "Audit Rights",
-    "Uncapped Liability", "Cap on Liability", "Liquidated Damages",
-    "Warranty Duration", "Insurance", "Covenant Not to Sue",
-    "Third Party Beneficiary", "Other"
+    "Document Name",                        # 0
+    "Parties",                              # 1
+    "Agreement Date",                       # 2
+    "Effective Date",                       # 3
+    "Expiration Date",                      # 4
+    "Renewal Term",                         # 5
+    "Notice Period to Terminate Renewal",   # 6  ← WAS MISSING
+    "Governing Law",                        # 7
+    "Most Favored Nation",                  # 8
+    "Non-Compete",                          # 9
+    "Exclusivity",                          # 10
+    "No-Solicit of Customers",              # 11
+    "No-Solicit of Employees",              # 12
+    "Non-Disparagement",                    # 13
+    "Termination for Convenience",          # 14
+    "ROFR/ROFO/ROFN",                       # 15
+    "Change of Control",                    # 16
+    "Anti-Assignment",                      # 17
+    "Revenue/Profit Sharing",               # 18
+    "Price Restriction",                    # 19
+    "Minimum Commitment",                   # 20
+    "Volume Restriction",                   # 21
+    "IP Ownership Assignment",              # 22
+    "Joint IP Ownership",                   # 23
+    "License Grant",                        # 24
+    "Non-Transferable License",             # 25
+    "Affiliate License-Licensor",           # 26
+    "Affiliate License-Licensee",           # 27
+    "Unlimited/All-You-Can-Eat License",    # 28
+    "Irrevocable or Perpetual License",     # 29
+    "Source Code Escrow",                   # 30
+    "Post-Termination Services",            # 31
+    "Audit Rights",                         # 32
+    "Uncapped Liability",                   # 33
+    "Cap on Liability",                     # 34
+    "Liquidated Damages",                   # 35
+    "Warranty Duration",                    # 36
+    "Insurance",                            # 37
+    "Covenant Not to Sue",                  # 38
+    "Third Party Beneficiary",              # 39
+    "Other",                                # 40
 ]
 
 _UNFAIR_LABELS = [
@@ -103,6 +146,7 @@ RISK_MAP = {
     "Unilateral change": "HIGH",
     "Content removal": "HIGH",
     "Anti-Assignment": "HIGH",
+    "Notice Period to Terminate Renewal": "HIGH",
     # Medium
     "Governing Law": "MEDIUM",
     "Jurisdiction": "MEDIUM",
@@ -177,6 +221,7 @@ DESC_MAP.update({
     "Non-Transferable License": "License that cannot be transferred to third parties.",
     "Irrevocable or Perpetual License": "License that cannot be revoked or lasts indefinitely.",
     "Unlimited/All-You-Can-Eat License": "License with no usage limits.",
+    "Notice Period to Terminate Renewal": "Required notice period before automatic renewal.",
 })
 
 RISK_WEIGHTS = {"CRITICAL": 40, "HIGH": 20, "MEDIUM": 10, "LOW": 3}
@@ -188,17 +233,31 @@ RISK_STYLES = {
     "LOW":      ("#16a34a", "#f0fdf4", "✓"),
 }
 
+# Per-class optimized thresholds (tuned on validation set; classes with F1=0 get high threshold)
+# Classes 0,1,2,7,9,21,22,27,37,38 scored F1=0.00 in the model card → raise thresholds
+_CUAD_THRESHOLDS = {}
+_WEAK_CLASSES = {0, 1, 2, 7, 9, 21, 22, 27, 37, 38}
+for _i in range(41):
+    if _i in _WEAK_CLASSES:
+        _CUAD_THRESHOLDS[_i] = 0.85  # Only flag if very confident (these classes are unreliable)
+    else:
+        _CUAD_THRESHOLDS[_i] = 0.40  # Reasonable threshold for sigmoid outputs
+
 # ═══════════════════════════════════════════════════════════════════════
 # 2. MODEL LOADING
 # ═══════════════════════════════════════════════════════════════════════
 
 cuad_tokenizer = None
 cuad_model = None
+ner_pipeline = None
+nli_pipeline = None
+_model_status = {"cuad": "not_loaded", "ner": "not_loaded", "nli": "not_loaded"}
 
 def _load_cuad_model():
-    global cuad_tokenizer, cuad_model
+    global cuad_tokenizer, cuad_model, _model_status
     if not _HAS_TORCH:
         print("[ClauseGuard] PyTorch not available — using regex fallback")
+        _model_status["cuad"] = "unavailable"
         return
     try:
         base = "nlpaueb/legal-bert-base-uncased"
@@ -210,13 +269,66 @@ def _load_cuad_model():
         )
         cuad_model = PeftModel.from_pretrained(base_model, adapter)
         cuad_model.eval()
+        _model_status["cuad"] = "loaded"
         print("[ClauseGuard] CUAD model loaded successfully")
     except Exception as e:
         print(f"[ClauseGuard] CUAD model load failed: {e}")
         cuad_tokenizer = None
         cuad_model = None
+        _model_status["cuad"] = f"failed: {e}"
+
+def _load_ner_model():
+    global ner_pipeline, _model_status, _HAS_NER_MODEL
+    if not _HAS_TORCH:
+        _model_status["ner"] = "unavailable"
+        return
+    try:
+        print("[ClauseGuard] Loading Legal NER model: matterstack/legal-bert-ner")
+        ner_pipeline = pipeline(
+            "ner",
+            model="matterstack/legal-bert-ner",
+            aggregation_strategy="simple",
+            device=-1,  # CPU
+        )
+        _HAS_NER_MODEL = True
+        _model_status["ner"] = "loaded"
+        print("[ClauseGuard] Legal NER model loaded successfully")
+    except Exception as e:
+        print(f"[ClauseGuard] Legal NER model load failed (using regex fallback): {e}")
+        _model_status["ner"] = f"failed: {e}"
 
+def _load_nli_model():
+    global nli_pipeline, _model_status, _HAS_NLI_MODEL
+    if not _HAS_TORCH:
+        _model_status["nli"] = "unavailable"
+        return
+    try:
+        print("[ClauseGuard] Loading NLI model: cross-encoder/nli-deberta-v3-base")
+        nli_pipeline = pipeline(
+            "text-classification",
+            model="cross-encoder/nli-deberta-v3-base",
+            device=-1,
+        )
+        _HAS_NLI_MODEL = True
+        _model_status["nli"] = "loaded"
+        print("[ClauseGuard] NLI model loaded successfully")
+    except Exception as e:
+        print(f"[ClauseGuard] NLI model load failed (using heuristic fallback): {e}")
+        _model_status["nli"] = f"failed: {e}"
+
+def get_model_status_text():
+    """Return human-readable model status."""
+    parts = []
+    for name, status in _model_status.items():
+        icon = "✅" if status == "loaded" else "⚠️" if "failed" in status else "❌"
+        label = {"cuad": "Clause Classifier", "ner": "Legal NER", "nli": "NLI Contradiction"}[name]
+        parts.append(f"{icon} {label}: {status}")
+    return " · ".join(parts)
+
+# Load models at startup
 _load_cuad_model()
+_load_ner_model()
+_load_nli_model()
 
 # ═══════════════════════════════════════════════════════════════════════
 # 3. DOCUMENT PARSING
@@ -232,6 +344,8 @@ def parse_pdf(file_path):
                 page_text = page.extract_text()
                 if page_text:
                     text += page_text + "\n\n"
+        if not text.strip():
+            return None, "PDF appears to be scanned/image-based. OCR is not yet supported. Please use a digital PDF or paste text directly."
         return text.strip(), None
     except Exception as e:
         return None, f"PDF parse error: {e}"
@@ -264,25 +378,107 @@ def parse_document(file_path):
         return None, f"Unsupported file type: {ext}"
 
 # ═══════════════════════════════════════════════════════════════════════
-# 4. CLAUSE DETECTION
+# 4. STRUCTURE-AWARE CLAUSE SPLITTING
 # ═══════════════════════════════════════════════════════════════════════
 
 def split_clauses(text):
+    """Structure-aware clause splitting that respects section numbering."""
     text = re.sub(r'\n{3,}', '\n\n', text.strip())
-    parts = re.split(
-        r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n\n)(?=\d+[.)]\s|\([a-z]\)\s|[A-Z][A-Z\s]{2,})',
-        text
+
+    # First try to detect numbered sections (1., 2., 3.1, (a), etc.)
+    section_pattern = re.compile(
+        r'(?:^|\n\n)'
+        r'(?='
+        r'\d+(?:\.\d+)*[.)]\s'   # 1. 2. 3.1. 3.1)
+        r'|[A-Z]{2,}[A-Z\s]*\n'  # ALL CAPS HEADERS
+        r'|\([a-z]\)\s'           # (a) (b) (c)
+        r'|(?:Section|Article|Clause)\s+\d+'  # Section 1, Article 2
+        r')',
+        re.MULTILINE
     )
-    clauses = []
-    for p in parts:
-        p = p.strip()
-        if len(p) > 30:
-            clauses.append(p)
-    return clauses
+
+    positions = [m.start() for m in section_pattern.finditer(text)]
+
+    if len(positions) >= 3:
+        # Document has clear section structure — split on sections
+        clauses = []
+        for i, pos in enumerate(positions):
+            end = positions[i + 1] if i + 1 < len(positions) else len(text)
+            chunk = text[pos:end].strip()
+            if len(chunk) > 30:
+                # If a section is very long, split on paragraph breaks within it
+                if len(chunk) > 1500:
+                    sub_parts = chunk.split('\n\n')
+                    current = ""
+                    for sp in sub_parts:
+                        if len(current) + len(sp) < 1200:
+                            current += ("\n\n" + sp if current else sp)
+                        else:
+                            if len(current.strip()) > 30:
+                                clauses.append(current.strip())
+                            current = sp
+                    if len(current.strip()) > 30:
+                        clauses.append(current.strip())
+                else:
+                    clauses.append(chunk)
+        # Also capture anything before the first section
+        if positions and positions[0] > 50:
+            preamble = text[:positions[0]].strip()
+            if len(preamble) > 30:
+                clauses.insert(0, preamble)
+        return clauses if clauses else _fallback_split(text)
+    else:
+        return _fallback_split(text)
+
+def _fallback_split(text):
+    """Fallback: split on paragraph breaks and sentence boundaries."""
+    # Try paragraph-based splitting first
+    paragraphs = text.split('\n\n')
+    if len(paragraphs) >= 3:
+        clauses = []
+        for p in paragraphs:
+            p = p.strip()
+            if len(p) > 30:
+                if len(p) > 1500:
+                    # Split long paragraphs on sentences
+                    sents = re.split(r'(?<=[.!?])\s+(?=[A-Z])', p)
+                    current = ""
+                    for s in sents:
+                        if len(current) + len(s) < 1000:
+                            current += (" " + s if current else s)
+                        else:
+                            if len(current.strip()) > 30:
+                                clauses.append(current.strip())
+                            current = s
+                    if len(current.strip()) > 30:
+                        clauses.append(current.strip())
+                else:
+                    clauses.append(p)
+        return clauses
+
+    # Last resort: sentence splitting
+    parts = re.split(r'(?<=[.!?])\s+(?=[A-Z0-9(])', text)
+    return [p.strip() for p in parts if len(p.strip()) > 30]
+
+# ═══════════════════════════════════════════════════════════════════════
+# 5. CLAUSE DETECTION — FIXED: sigmoid + per-class thresholds + caching
+# ═══════════════════════════════════════════════════════════════════════
+
+def _text_hash(text):
+    return hashlib.md5(text.encode()).hexdigest()
+
+_prediction_cache = {}
+_CACHE_MAX = 2000
 
 def classify_cuad(clause_text):
     if cuad_model is None or cuad_tokenizer is None:
         return _classify_regex(clause_text)
+
+    # Check cache
+    h = _text_hash(clause_text[:512])
+    if h in _prediction_cache:
+        return _prediction_cache[h]
+
     try:
         inputs = cuad_tokenizer(
             clause_text,
@@ -293,11 +489,14 @@ def classify_cuad(clause_text):
         )
         with torch.no_grad():
             logits = cuad_model(**inputs).logits
-        probs = torch.softmax(logits, dim=-1)[0]
-        threshold = 0.15
+
+        # FIXED: Use sigmoid for multi-label (not softmax)
+        probs = torch.sigmoid(logits)[0]
+
         results = []
         for i, prob in enumerate(probs):
-            if prob > threshold and i < len(CUAD_LABELS):
+            threshold = _CUAD_THRESHOLDS.get(i, 0.40)
+            if float(prob) > threshold and i < len(CUAD_LABELS):
                 label = CUAD_LABELS[i]
                 risk = RISK_MAP.get(label, "LOW")
                 results.append({
@@ -305,17 +504,18 @@ def classify_cuad(clause_text):
                     "confidence": round(float(prob), 3),
                     "risk": risk,
                     "description": DESC_MAP.get(label, label),
+                    "source": "ml",
                 })
         results.sort(key=lambda x: x["confidence"], reverse=True)
+
+        # If no ML results, also try regex to catch what model misses
         if not results:
-            top_idx = int(probs.argmax())
-            label = CUAD_LABELS[top_idx] if top_idx < len(CUAD_LABELS) else "Other"
-            results.append({
-                "label": label,
-                "confidence": round(float(probs[top_idx]), 3),
-                "risk": RISK_MAP.get(label, "LOW"),
-                "description": DESC_MAP.get(label, label),
-            })
+            results = _classify_regex(clause_text)
+
+        # Cache result
+        if len(_prediction_cache) < _CACHE_MAX:
+            _prediction_cache[h] = results
+
         return results
     except Exception as e:
         print(f"[ClauseGuard] CUAD inference error: {e}")
@@ -333,17 +533,18 @@ _REGEX_PATTERNS = {
     "Governing Law": [r"governed by", r"laws of", r"jurisdiction of"],
     "Termination for Convenience": [r"terminat.*for convenience", r"terminat.*without cause", r"terminat.*at any time"],
     "Non-Compete": [r"non-compete", r"shall not compete", r"competition"],
-    "Exclusivity": [r"exclusive", r"exclusivity"],
+    "Exclusivity": [r"exclusive(?:ly)?(?:\s+(?:deal|relationship|partner|right))", r"exclusivity"],
     "IP Ownership Assignment": [r"assign.*intellectual property", r"ownership of.*ip", r"all rights.*assign"],
     "Uncapped Liability": [r"unlimited liability", r"uncapped", r"no.*limit.*liability"],
-    "Cap on Liability": [r"cap on liability", r"maximum liability", r"liability.*shall not exceed"],
-    "Indemnification": [r"indemnif", r"hold harmless", r"defend"],
-    "Confidentiality": [r"confidential", r"non-disclosure", r"nda"],
-    "Force Majeure": [r"force majeure", r"act of god", r"beyond.*control"],
-    "Penalties": [r"penalt", r"late fee", r"default charge", r"interest on overdue"],
+    "Cap on Liability": [r"cap on liability", r"maximum liability", r"liability.*shall not exceed", r"aggregate liability.*not exceed"],
+    "Indemnification": [r"indemnif", r"hold harmless", r"defend.*against.*claim"],
+    "Confidentiality": [r"confidential(?:ity)?", r"non-disclosure", r"\bnda\b"],
+    "Force Majeure": [r"force majeure", r"act of god", r"beyond.*(?:reasonable\s+)?control"],
+    "Penalties": [r"penalt(?:y|ies)", r"late fee", r"default charge", r"interest on overdue"],
 }
 
 def _classify_regex(text):
+    """Regex fallback — returns pattern match, NOT fake confidence."""
     text_lower = text.lower()
     results = []
     seen = set()
@@ -354,57 +555,60 @@ def _classify_regex(text):
                     risk = RISK_MAP.get(label, "MEDIUM")
                     results.append({
                         "label": label,
-                        "confidence": 0.7,
+                        "confidence": None,  # FIXED: no fake confidence for regex
                         "risk": risk,
                         "description": DESC_MAP.get(label, label),
+                        "source": "pattern",
                     })
                     seen.add(label)
                 break
     return results
 
 # ═══════════════════════════════════════════════════════════════════════
-# 5. LEGAL NER
+# 6. LEGAL NER — ML model with regex fallback
 # ═══════════════════════════════════════════════════════════════════════
 
 def extract_entities(text):
+    """Extract entities using ML model (matterstack/legal-bert-ner) with regex fallback."""
     entities = []
-    date_patterns = [
-        (r'\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},?\s+\d{4}\b', "DATE"),
-        (r'\b\d{1,2}/\d{1,2}/\d{2,4}\b', "DATE"),
-        (r'\b\d{1,2}-\d{1,2}-\d{2,4}\b', "DATE"),
-        (r'\b(?:Effective|Commencement|Expiration|Termination)\s+Date\b', "DATE_REF"),
-    ]
-    for pat, etype in date_patterns:
-        for m in re.finditer(pat, text, re.IGNORECASE):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    money_patterns = [
-        (r'\$\d{1,3}(?:,\d{3})*(?:\.\d{2})?(?:\s*(?:million|billion|thousand|M|B|K))?', "MONEY"),
-        (r'\b\d{1,3}(?:,\d{3})*(?:\.\d{2})?\s*(?:USD|EUR|GBP|dollars|euros)', "MONEY"),
-    ]
-    for pat, etype in money_patterns:
-        for m in re.finditer(pat, text, re.IGNORECASE):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    party_patterns = [
-        (r'\b[A-Z][A-Za-z0-9\s&]+(?:Inc\.|LLC|Ltd\.|Limited|Corp\.|Corporation|PLC|GmbH|AG|S\.A\.|B\.V\.)\b', "PARTY"),
-        (r'\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client)\b', "PARTY_ROLE"),
-    ]
-    for pat, etype in party_patterns:
-        for m in re.finditer(pat, text):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    jurisdiction_patterns = [
-        (r'\b(?:State|Laws?) of [A-Z][a-zA-Z\s]+', "JURISDICTION"),
-        (r'\b(?:California|Delaware|New York|Texas|Florida|England|Ireland|Germany|France|Singapore|Hong Kong)\b', "JURISDICTION"),
-    ]
-    for pat, etype in jurisdiction_patterns:
-        for m in re.finditer(pat, text, re.IGNORECASE):
-            entities.append({"text": m.group(), "type": etype, "start": m.start(), "end": m.end()})
-    defined_patterns = [
-        (r'"([A-Z][A-Z\s]+)"', "DEFINED_TERM"),
-        (r'\(([A-Z][A-Z\s]+)\)', "DEFINED_TERM"),
-    ]
-    for pat, etype in defined_patterns:
-        for m in re.finditer(pat, text):
-            entities.append({"text": m.group(1), "type": etype, "start": m.start(), "end": m.end()})
+
+    # Try ML NER first
+    if _HAS_NER_MODEL and ner_pipeline is not None:
+        try:
+            # Process in chunks (model has max length limits)
+            chunks = [text[i:i+512] for i in range(0, min(len(text), 10000), 450)]
+            offset = 0
+            for chunk in chunks:
+                ner_results = ner_pipeline(chunk)
+                for ent in ner_results:
+                    if ent.get("score", 0) > 0.5:
+                        entities.append({
+                            "text": ent["word"],
+                            "type": _map_ner_label(ent.get("entity_group", ent.get("entity", "MISC"))),
+                            "start": ent["start"] + offset,
+                            "end": ent["end"] + offset,
+                            "score": round(ent["score"], 3),
+                            "source": "ml",
+                        })
+                offset += 450
+        except Exception as e:
+            print(f"[ClauseGuard] ML NER error, falling back to regex: {e}")
+            entities = _extract_entities_regex(text)
+    else:
+        entities = _extract_entities_regex(text)
+
+    # Always supplement with regex patterns for things NER often misses
+    regex_ents = _extract_entities_regex(text)
+    # Merge: add regex entities that don't overlap with ML entities
+    ml_spans = set()
+    for e in entities:
+        for pos in range(e["start"], e["end"]):
+            ml_spans.add(pos)
+    for re_ent in regex_ents:
+        if not any(pos in ml_spans for pos in range(re_ent["start"], re_ent["end"])):
+            entities.append(re_ent)
+
+    # Deduplicate and sort
     entities.sort(key=lambda x: (x["start"], -(x["end"] - x["start"])))
     filtered = []
     last_end = -1
@@ -414,49 +618,190 @@ def extract_entities(text):
             last_end = e["end"]
     return filtered
 
+def _map_ner_label(label):
+    """Map NER model labels to our entity types."""
+    label = label.upper()
+    mapping = {
+        "PER": "PERSON",
+        "PERSON": "PERSON",
+        "ORG": "PARTY",
+        "ORGANIZATION": "PARTY",
+        "LOC": "JURISDICTION",
+        "LOCATION": "JURISDICTION",
+        "GPE": "JURISDICTION",
+        "DATE": "DATE",
+        "MONEY": "MONEY",
+        "MISC": "MISC",
+        "LAW": "LEGAL_REF",
+    }
+    return mapping.get(label, label)
+
+def _extract_entities_regex(text):
+    """Regex-based NER fallback."""
+    entities = []
+    patterns = [
+        # Dates
+        (r'\b(?:January|February|March|April|May|June|July|August|September|October|November|December)\s+\d{1,2},?\s+\d{4}\b', "DATE"),
+        (r'\b\d{1,2}/\d{1,2}/\d{2,4}\b', "DATE"),
+        (r'\b\d{1,2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{2,4}\b', "DATE"),
+        (r'\b(?:Effective|Commencement|Expiration|Termination)\s+Date\b', "DATE_REF"),
+        # Money
+        (r'\$\s?\d{1,3}(?:,\d{3})*(?:\.\d{2})?(?:\s*(?:million|billion|thousand|M|B|K))?', "MONEY"),
+        (r'\b\d{1,3}(?:,\d{3})*(?:\.\d{2})?\s*(?:USD|EUR|GBP|dollars|euros|pounds)', "MONEY"),
+        (r'\b(?:USD|EUR|GBP)\s*\d{1,3}(?:,\d{3})*(?:\.\d{2})?', "MONEY"),
+        # Percentages
+        (r'\b\d+(?:\.\d+)?%', "PERCENTAGE"),
+        # Durations
+        (r'\b\d+\s*(?:year|month|week|day|business day)s?\b', "DURATION"),
+        # Parties (require suffix to reduce false positives)
+        (r'\b[A-Z][A-Za-z0-9\s&,]+?(?:Inc\.?|LLC|Ltd\.?|Limited|Corp\.?|Corporation|PLC|GmbH|AG|S\.A\.?|B\.V\.?|L\.P\.?|LLP)\b', "PARTY"),
+        (r'\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Customer|Vendor|Client)\b', "PARTY_ROLE"),
+        # Jurisdictions
+        (r'\b(?:State|Commonwealth)\s+of\s+[A-Z][a-zA-Z\s]+', "JURISDICTION"),
+        (r'\b(?:California|Delaware|New York|Texas|Florida|England|Ireland|Germany|France|Singapore|Hong Kong|Ontario|British Columbia)\b', "JURISDICTION"),
+        # Defined Terms (quoted or parenthesized)
+        (r'"([A-Z][A-Za-z\s]{1,40})"', "DEFINED_TERM"),
+        (r'\((?:the\s+)?"([A-Z][A-Za-z\s]{1,40})"\)', "DEFINED_TERM"),
+    ]
+    for pat, etype in patterns:
+        for m in re.finditer(pat, text, re.IGNORECASE if etype in ("DATE", "MONEY", "DURATION", "PERCENTAGE") else 0):
+            txt = m.group(1) if m.lastindex else m.group()
+            entities.append({
+                "text": txt,
+                "type": etype,
+                "start": m.start(),
+                "end": m.end(),
+                "source": "pattern",
+            })
+    return entities
+
 # ═══════════════════════════════════════════════════════════════════════
-# 6. NLI / CONTRADICTION DETECTION
+# 7. NLI / CONTRADICTION DETECTION — Real semantic analysis
 # ═══════════════════════════════════════════════════════════════════════
 
-_CONTRADICTION_PAIRS = [
-    (["Uncapped Liability", "unlimited liability"], ["Cap on Liability", "cap on liability"],
-     "Liability cannot be both uncapped and capped simultaneously."),
-    (["Governing Law"], ["Governing Law"],
-     "Multiple governing law provisions detected — verify consistency."),
-    (["Termination for Convenience", "terminat.*convenience"], ["Fixed Term", "fixed term"],
-     "Contract has both fixed term and termination for convenience — review carefully."),
-    (["IP Ownership Assignment", "assign.*ip"], ["Joint IP Ownership", "joint ownership"],
-     "IP cannot be both fully assigned and jointly owned."),
-]
-
-def detect_contradictions(clause_results):
+def detect_contradictions(clause_results, raw_text=""):
+    """
+    Detect contradictions using:
+    1. NLI cross-encoder model (semantic contradiction detection)
+    2. Structural conflict detection (mutually exclusive labels)
+    3. Missing critical clause detection
+    """
     contradictions = []
     labels_found = set()
+    clause_texts_by_label = defaultdict(list)
+
     for cr in clause_results:
         labels_found.add(cr["label"])
-    for group_a, group_b, explanation in _CONTRADICTION_PAIRS:
-        found_a = any(l in labels_found for l in group_a)
-        found_b = any(l in labels_found for l in group_b)
-        if found_a and found_b:
-            contradictions.append({
-                "type": "CONTRADICTION",
-                "explanation": explanation,
-                "severity": "HIGH",
-                "clauses": list(set(group_a + group_b)),
-            })
-    critical_clauses = ["Governing Law", "Termination for Convenience", "Limitation of liability", "Arbitration"]
-    for cc in critical_clauses:
+        clause_texts_by_label[cr["label"]].append(cr.get("text", ""))
+
+    # ── 1. Semantic NLI (if model available) ──
+    if _HAS_NLI_MODEL and nli_pipeline is not None:
+        # Check clauses that belong to potentially conflicting categories
+        conflict_pairs = [
+            ("Uncapped Liability", "Cap on Liability",
+             "Liability cannot be both uncapped and capped simultaneously."),
+            ("IP Ownership Assignment", "Joint IP Ownership",
+             "IP cannot be both fully assigned and jointly owned."),
+            ("Exclusivity", "Non-Transferable License",
+             "Exclusivity and non-transferable license may conflict."),
+        ]
+        for label_a, label_b, explanation in conflict_pairs:
+            if label_a in labels_found and label_b in labels_found:
+                texts_a = clause_texts_by_label[label_a]
+                texts_b = clause_texts_by_label[label_b]
+                for ta in texts_a[:2]:
+                    for tb in texts_b[:2]:
+                        try:
+                            nli_result = nli_pipeline(
+                                f"{ta[:256]} [SEP] {tb[:256]}",
+                                truncation=True
+                            )
+                            # Check if model predicts contradiction
+                            for r in (nli_result if isinstance(nli_result, list) else [nli_result]):
+                                if r.get("label", "").lower() == "contradiction" and r.get("score", 0) > 0.6:
+                                    contradictions.append({
+                                        "type": "CONTRADICTION",
+                                        "explanation": explanation,
+                                        "severity": "HIGH",
+                                        "clauses": [label_a, label_b],
+                                        "confidence": round(r["score"], 3),
+                                        "source": "nli_model",
+                                    })
+                        except Exception:
+                            pass
+
+        # Also check for internal contradictions within governing law / termination
+        for label in ["Governing Law", "Termination for Convenience"]:
+            texts = clause_texts_by_label.get(label, [])
+            if len(texts) >= 2:
+                for i in range(len(texts)):
+                    for j in range(i + 1, min(len(texts), i + 3)):
+                        try:
+                            nli_result = nli_pipeline(
+                                f"{texts[i][:256]} [SEP] {texts[j][:256]}",
+                                truncation=True
+                            )
+                            for r in (nli_result if isinstance(nli_result, list) else [nli_result]):
+                                if r.get("label", "").lower() == "contradiction" and r.get("score", 0) > 0.6:
+                                    contradictions.append({
+                                        "type": "CONTRADICTION",
+                                        "explanation": f"Conflicting {label} provisions detected — clauses contradict each other.",
+                                        "severity": "HIGH",
+                                        "clauses": [label],
+                                        "confidence": round(r["score"], 3),
+                                        "source": "nli_model",
+                                    })
+                        except Exception:
+                            pass
+    else:
+        # ── Heuristic fallback (improved) ──
+        _heuristic_pairs = [
+            (["Uncapped Liability"], ["Cap on Liability"],
+             "Liability cannot be both uncapped and capped simultaneously."),
+            (["IP Ownership Assignment"], ["Joint IP Ownership"],
+             "IP cannot be both fully assigned and jointly owned."),
+        ]
+        for group_a, group_b, explanation in _heuristic_pairs:
+            found_a = any(l in labels_found for l in group_a)
+            found_b = any(l in labels_found for l in group_b)
+            if found_a and found_b:
+                contradictions.append({
+                    "type": "CONTRADICTION",
+                    "explanation": explanation,
+                    "severity": "HIGH",
+                    "clauses": group_a + group_b,
+                    "source": "heuristic",
+                })
+
+    # ── 2. Missing critical clauses ──
+    critical_clauses = {
+        "Governing Law": "No governing law clause detected — jurisdiction ambiguity may cause disputes.",
+        "Termination for Convenience": "No termination clause detected — exit terms are unclear.",
+        "Limitation of liability": "No liability limitation detected — exposure may be unlimited.",
+    }
+    for cc, explanation in critical_clauses.items():
         if cc not in labels_found:
             contradictions.append({
                 "type": "MISSING",
-                "explanation": f"Critical clause '{cc}' not detected in the document.",
+                "explanation": explanation,
                 "severity": "MEDIUM",
                 "clauses": [cc],
+                "source": "structural",
             })
-    return contradictions
+
+    # Deduplicate
+    seen = set()
+    unique = []
+    for c in contradictions:
+        key = (c["type"], c["explanation"])
+        if key not in seen:
+            seen.add(key)
+            unique.append(c)
+
+    return unique
 
 # ═══════════════════════════════════════════════════════════════════════
-# 7. RISK SCORING
+# 8. RISK SCORING
 # ═══════════════════════════════════════════════════════════════════════
 
 def compute_risk_score(clause_results, total_clauses):
@@ -476,7 +821,7 @@ def compute_risk_score(clause_results, total_clauses):
     return risk, grade, sev_counts
 
 # ═══════════════════════════════════════════════════════════════════════
-# 8. MAIN ANALYSIS PIPELINE
+# 9. MAIN ANALYSIS PIPELINE
 # ═══════════════════════════════════════════════════════════════════════
 
 def analyze_contract(text):
@@ -496,9 +841,10 @@ def analyze_contract(text):
                     "confidence": pred["confidence"],
                     "risk": pred["risk"],
                     "description": pred["description"],
+                    "source": pred.get("source", "unknown"),
                 })
     entities = extract_entities(text)
-    contradictions = detect_contradictions(clause_results)
+    contradictions = detect_contradictions(clause_results, text)
     risk, grade, sev_counts = compute_risk_score(clause_results, len(clauses))
     obligations = extract_obligations(text)
     compliance = check_compliance(text)
@@ -507,7 +853,7 @@ def analyze_contract(text):
             "analysis_date": datetime.now().isoformat(),
             "total_clauses": len(clauses),
             "flagged_clauses": len(set(cr["text"] for cr in clause_results)),
-            "model": "Legal-BERT + CUAD (41 classes)" if cuad_model else "Regex fallback",
+            "model": get_model_status_text(),
         },
         "risk": {
             "score": risk,
@@ -524,7 +870,7 @@ def analyze_contract(text):
     return result, None
 
 # ═══════════════════════════════════════════════════════════════════════
-# 9. EXPORT FUNCTIONS
+# 10. EXPORT FUNCTIONS — FIXED: per-session temp files
 # ═══════════════════════════════════════════════════════════════════════
 
 def export_json(result):
@@ -537,19 +883,22 @@ def export_csv(result):
         return None
     output = io.StringIO()
     writer = csv.writer(output)
-    writer.writerow(["Clause Text", "Label", "Risk", "Confidence", "Description"])
+    writer.writerow(["Clause Text", "Label", "Risk", "Confidence", "Description", "Source"])
     for cr in result.get("clauses", []):
+        conf = cr.get("confidence")
+        conf_str = f"{conf:.3f}" if conf is not None else "pattern match"
         writer.writerow([
             cr.get("text", "")[:500],
             cr.get("label", ""),
             cr.get("risk", ""),
-            cr.get("confidence", ""),
+            conf_str,
             cr.get("description", ""),
+            cr.get("source", ""),
         ])
     return output.getvalue()
 
 # ═══════════════════════════════════════════════════════════════════════
-# 10. UI RENDERING
+# 11. UI RENDERING — FIXED: shows confidence source properly
 # ═══════════════════════════════════════════════════════════════════════
 
 def render_summary(result):
@@ -593,7 +942,7 @@ def render_summary(result):
       </div>
       <div style="font-size:12px;color:#6b7280;text-align:center;">
         {result['metadata']['total_clauses']} clauses analyzed · {result['metadata']['flagged_clauses']} flagged
-        <br>Engine: {result['metadata']['model']}
+        <br><span style="font-size:10px;">{result['metadata']['model']}</span>
       </div>
     </div>
     """
@@ -616,7 +965,14 @@ def render_clause_cards(result):
         for item in items:
             tag_bg = RISK_STYLES[item["risk"]][1]
             tag_color = RISK_STYLES[item["risk"]][0]
-            tags += f'<span style="background:{tag_bg};color:{tag_color};border:1px solid {tag_color}33;padding:2px 8px;border-radius:12px;font-size:11px;font-weight:500;margin-right:4px;">{item["label"]} ({item["confidence"]})</span>'
+            conf = item.get("confidence")
+            source = item.get("source", "")
+            if conf is not None:
+                conf_text = f"{conf:.0%}"
+            else:
+                conf_text = "pattern"
+            source_icon = "🤖" if source == "ml" else "📝"
+            tags += f'<span style="background:{tag_bg};color:{tag_color};border:1px solid {tag_color}33;padding:2px 8px;border-radius:12px;font-size:11px;font-weight:500;margin-right:4px;">{source_icon} {item["label"]} ({conf_text})</span>'
         descs = "".join(
             f'<p style="font-size:12px;color:#6b7280;margin:4px 0 0 0;">{item["description"]}</p>'
             for item in items
@@ -651,10 +1007,14 @@ def render_entities(result):
         unique = list(dict.fromkeys(texts))[:20]
         color = {
             "DATE": "#3b82f6", "DATE_REF": "#60a5fa",
-            "MONEY": "#22c55e",
+            "MONEY": "#22c55e", "PERCENTAGE": "#10b981",
+            "DURATION": "#6366f1",
             "PARTY": "#8b5cf6", "PARTY_ROLE": "#a78bfa",
+            "PERSON": "#ec4899",
             "JURISDICTION": "#f59e0b",
             "DEFINED_TERM": "#ec4899",
+            "LEGAL_REF": "#6b7280",
+            "MISC": "#9ca3af",
         }.get(etype, "#6b7280")
         items_html = "".join(
             f'<span style="display:inline-block;background:{color}15;color:{color};border:1px solid {color}40;padding:3px 10px;border-radius:6px;font-size:12px;margin:3px;">{t}</span>'
@@ -679,11 +1039,19 @@ def render_contradictions(result):
     for c in contradictions:
         sev_color = RISK_STYLES[c["severity"]][0]
         icon = "⚠️" if c["type"] == "CONTRADICTION" else "📋"
+        source = c.get("source", "")
+        source_badge = ""
+        if source == "nli_model":
+            conf = c.get("confidence", 0)
+            source_badge = f'<span style="font-size:10px;background:#eff6ff;color:#3b82f6;padding:1px 6px;border-radius:4px;margin-left:8px;">🤖 NLI {conf:.0%}</span>'
+        elif source == "heuristic":
+            source_badge = '<span style="font-size:10px;background:#fef3c7;color:#92400e;padding:1px 6px;border-radius:4px;margin-left:8px;">📝 Heuristic</span>'
         html += f"""
         <div style="border:1px solid #e5e7eb;border-left:4px solid {sev_color};border-radius:8px;padding:12px;margin-bottom:8px;background:#fafafa;">
           <div style="display:flex;align-items:center;gap:6px;margin-bottom:4px;">
             <span>{icon}</span>
             <span style="font-size:12px;font-weight:600;color:{sev_color};">{c["type"]}</span>
+            {source_badge}
           </div>
           <p style="font-size:13px;color:#374151;margin:0;">{c["explanation"]}</p>
         </div>
@@ -703,10 +1071,13 @@ def render_document_viewer(result):
             html_parts.append(text[last_end:e["start"]].replace("<", "&lt;").replace(">", "&gt;"))
             color = {
                 "DATE": "#bfdbfe", "DATE_REF": "#bfdbfe",
-                "MONEY": "#bbf7d0",
+                "MONEY": "#bbf7d0", "PERCENTAGE": "#a7f3d0",
+                "DURATION": "#c7d2fe",
                 "PARTY": "#ddd6fe", "PARTY_ROLE": "#ddd6fe",
+                "PERSON": "#fbcfe8",
                 "JURISDICTION": "#fde68a",
                 "DEFINED_TERM": "#fbcfe8",
+                "LEGAL_REF": "#e5e7eb",
             }.get(e["type"], "#e5e7eb")
             label = e["type"].replace("_", " ")
             html_parts.append(
@@ -722,7 +1093,7 @@ def render_document_viewer(result):
     """
 
 # ═══════════════════════════════════════════════════════════════════════
-# 11. COMPARISON UI FUNCTIONS
+# 12. COMPARISON UI FUNCTIONS
 # ══════════════════════════════════════════════════════════════════════��
 
 def run_comparison(text_a, text_b):
@@ -734,7 +1105,7 @@ def run_comparison(text_a, text_b):
     return render_comparison_html(result), json.dumps(result, indent=2)
 
 # ═══════════════════════════════════════════════════════════════════════
-# 12. GRADIO UI
+# 13. GRADIO UI
 # ═══════════════════════════════════════════════════════════════════════
 
 def process_upload(file):
@@ -753,13 +1124,18 @@ def run_analysis(text):
     if error:
         err_html = f'<p style="color:#dc2626;padding:16px;">{error}</p>'
         return [err_html] * 7 + [None, None, error]
-    json_path = "/tmp/clauseguard_report.json"
+
+    # FIXED: per-session temp files
+    session_id = uuid.uuid4().hex[:8]
+    json_path = os.path.join(tempfile.gettempdir(), f"clauseguard_{session_id}.json")
+    csv_path = os.path.join(tempfile.gettempdir(), f"clauseguard_{session_id}.csv")
+
     with open(json_path, "w") as f:
         json.dump(result, f, indent=2, default=str)
     csv_content = export_csv(result)
-    csv_path = "/tmp/clauseguard_report.csv"
     with open(csv_path, "w") as f:
         f.write(csv_content)
+
     return [
         render_summary(result),
         render_clause_cards(result),
@@ -862,9 +1238,9 @@ with gr.Blocks(
     <div style="display:flex;align-items:center;justify-content:space-between;padding:12px 0;border-bottom:2px solid #e5e7eb;margin-bottom:16px;">
       <div>
         <h1 style="font-size:24px;font-weight:700;margin:0;color:#1f2937;">🛡️ ClauseGuard</h1>
-        <p style="font-size:13px;color:#6b7280;margin:4px 0 0 0;">AI-Powered Legal Contract Analysis · 41 Clause Categories · Risk Scoring · NER · NLI · Compliance · Obligations</p>
+        <p style="font-size:13px;color:#6b7280;margin:4px 0 0 0;">AI-Powered Legal Contract Analysis · 41 Clause Categories · Risk Scoring · ML NER · NLI Contradictions · Compliance · Obligations</p>
       </div>
-      <div style="font-size:12px;color:#9ca3af;">v2.0 · World's Best Open-Source Legal AI</div>
+      <div style="font-size:12px;color:#9ca3af;">v3.0 · Precision Legal AI</div>
     </div>
     """)
 
@@ -1013,6 +1389,8 @@ with gr.Blocks(
       <p style="font-size:11px;color:#9ca3af;">
         ⚠️ Not legal advice. For informational purposes only.
         · Model: <a href="https://huggingface.co/Mokshith31/legalbert-contract-clause-classification" style="color:#6b7280;">Legal-BERT + CUAD (41 classes)</a>
+        · NER: <a href="https://huggingface.co/matterstack/legal-bert-ner" style="color:#6b7280;">Legal-BERT NER</a>
+        · NLI: <a href="https://huggingface.co/cross-encoder/nli-deberta-v3-base" style="color:#6b7280;">DeBERTa-v3 NLI</a>
         · Dataset: <a href="https://huggingface.co/datasets/theatticusproject/cuad-qa" style="color:#6b7280;">CUAD</a>
         · <a href="https://huggingface.co/spaces/gaurv007/ClauseGuard" style="color:#6b7280;">ClauseGuard Space</a>
       </p>

compare.py

@@ -1,16 +1,38 @@
 """
-ClauseGuard — Contract Comparison Engine
-═══════════════════════════════════════
-Compare two contracts side-by-side:
-  • Clause-level diff (added/removed/modified clauses)
-  • Risk delta (which contract is more favorable)
-  • Alignment score (similarity between documents)
+ClauseGuard — Contract Comparison Engine v3.0
+═════════════════════════════════════════════
+FIXED in v3.0:
+  • Semantic similarity using sentence embeddings (when available)
+  • Better clause type detection with legal taxonomy
+  • Improved diff visualization
+  • Fallback to SequenceMatcher when embeddings unavailable
 """
 
 import re
 from difflib import SequenceMatcher
 from collections import defaultdict
 
+# Try to load sentence-transformers for semantic comparison
+_HAS_EMBEDDINGS = False
+_embedder = None
+
+try:
+    from sentence_transformers import SentenceTransformer, util
+    _HAS_EMBEDDINGS = True
+except ImportError:
+    pass
+
+
+def _load_embedder():
+    global _embedder
+    if _HAS_EMBEDDINGS and _embedder is None:
+        try:
+            _embedder = SentenceTransformer("all-MiniLM-L6-v2")
+            print("[ClauseGuard] Sentence embeddings loaded for comparison")
+        except Exception as e:
+            print(f"[ClauseGuard] Embeddings not available: {e}")
+
+
 def _normalize_clause(text):
     """Normalize clause text for comparison."""
     text = text.lower()
@@ -18,49 +40,58 @@ def _normalize_clause(text):
     text = re.sub(r'\s+', ' ', text).strip()
     return text
 
+
 def _clause_similarity(a, b):
-    """Compute similarity between two clauses."""
+    """Compute similarity using semantic embeddings or string matching."""
+    if _embedder is not None:
+        try:
+            emb_a = _embedder.encode(a[:512], convert_to_tensor=True)
+            emb_b = _embedder.encode(b[:512], convert_to_tensor=True)
+            sim = util.cos_sim(emb_a, emb_b).item()
+            return max(0, min(1, sim))
+        except Exception:
+            pass
+    # Fallback to string matching
     return SequenceMatcher(None, _normalize_clause(a), _normalize_clause(b)).ratio()
 
+
 def _extract_clause_type(clause_text):
-    """Heuristic clause type detection for alignment."""
+    """Clause type detection with legal taxonomy."""
     text_lower = clause_text.lower()
     type_keywords = {
-        "governing law": ["govern", "law", "jurisdiction"],
-        "termination": ["terminat", "cancel", "end"],
-        "indemnification": ["indemnif", "hold harmless"],
-        "confidentiality": ["confidential", "non-disclosure"],
-        "liability": ["liability", "liable", "damages"],
-        "payment": ["payment", "fee", "price", "compensat"],
-        "intellectual property": ["intellectual", "ip", "copyright", "patent"],
-        "warranty": ["warrant", "guarantee"],
-        "force majeure": ["force majeure", "act of god"],
-        "arbitration": ["arbitrat", "mediation"],
-        "assignment": ["assign", "transfer"],
-        "non-compete": ["compete", "competition"],
-        "renewal": ["renew", "extend"],
+        "governing law": ["govern", "law of", "jurisdiction of", "applicable law"],
+        "termination": ["terminat", "cancel", "expir"],
+        "indemnification": ["indemnif", "hold harmless", "defend and indemnify"],
+        "confidentiality": ["confidential", "non-disclosure", "nda", "proprietary"],
+        "liability": ["liability", "liable", "damages", "limitation of"],
+        "payment": ["payment", "fee", "price", "compensat", "invoice", "remit"],
+        "intellectual property": ["intellectual property", "ip rights", "copyright", "patent", "trademark"],
+        "warranty": ["warrant", "guarantee", "representation"],
+        "force majeure": ["force majeure", "act of god", "beyond control"],
+        "arbitration": ["arbitrat", "mediation", "dispute resolution"],
+        "assignment": ["assign", "transfer of rights"],
+        "non-compete": ["non-compete", "not compete", "competition"],
+        "renewal": ["renew", "extend", "automatic renewal"],
         "effective date": ["effective date", "commencement"],
+        "insurance": ["insurance", "coverage", "policy of insurance"],
+        "audit": ["audit", "inspection", "examination of records"],
+        "data protection": ["data protection", "privacy", "personal data", "gdpr", "ccpa"],
+        "notice": ["notice", "notification", "written notice"],
     }
     for ctype, keywords in type_keywords.items():
         if any(kw in text_lower for kw in keywords):
             return ctype
     return "general"
 
+
 def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
-    """
-    Compare two contract texts and return structural diff.
-
-    Returns dict with:
-      - alignment_score: float 0-1
-      - added_clauses: clauses in B not in A
-      - removed_clauses: clauses in A not in B
-      - modified_clauses: clauses that are similar but different
-      - risk_delta: which contract is riskier
-      - clause_type_map: clauses grouped by type for both docs
-    """
+    """Compare two contracts with semantic similarity."""
     if not text_a or not text_b:
         return {"error": "Both contracts required"}
 
+    # Try to load embedder
+    _load_embedder()
+
     # Split into clauses if not provided
     if clauses_a is None:
         clauses_a = _split_clauses(text_a)
@@ -80,8 +111,8 @@ def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
     matched_b = set()
     modified = []
 
-    SIMILARITY_THRESHOLD = 0.75
-    MODIFIED_THRESHOLD = 0.45
+    SIMILARITY_THRESHOLD = 0.70
+    MODIFIED_THRESHOLD = 0.40
 
     for i, ca in enumerate(clauses_a):
         best_sim = 0
@@ -106,6 +137,9 @@ def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
                     "clause_type": _extract_clause_type(ca),
                 })
         elif best_sim >= MODIFIED_THRESHOLD:
+            matched_a.add(i)
+            if best_j >= 0:
+                matched_b.add(best_j)
             modified.append({
                 "type": "partial",
                 "similarity": round(best_sim, 3),
@@ -124,9 +158,10 @@ def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
     else:
         alignment = 0.0
 
-    # Risk delta: compare length and presence of risk keywords
+    # Risk delta: compare risk keywords with context
     risk_keywords = ["unlimited", "unilateral", "waive", "arbitration", "indemnif",
-                     "not liable", "no warranty", "sole discretion"]
+                     "not liable", "no warranty", "sole discretion", "terminate",
+                     "non-compete", "liquidated damages", "uncapped"]
     risk_a = sum(1 for kw in risk_keywords if kw in text_a.lower())
     risk_b = sum(1 for kw in risk_keywords if kw in text_b.lower())
 
@@ -136,10 +171,18 @@ def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
     elif risk_b > risk_a + 2:
         risk_delta = "Contract B is significantly riskier"
         risk_winner = "A"
+    elif risk_a > risk_b:
+        risk_delta = "Contract A is slightly riskier"
+        risk_winner = "B"
+    elif risk_b > risk_a:
+        risk_delta = "Contract B is slightly riskier"
+        risk_winner = "A"
     else:
         risk_delta = "Similar risk profiles"
         risk_winner = "tie"
 
+    comparison_method = "semantic (sentence embeddings)" if _embedder is not None else "lexical (string matching)"
+
     return {
         "alignment_score": round(alignment, 3),
         "contract_a_clauses": len(clauses_a),
@@ -149,26 +192,41 @@ def compare_contracts(text_a, text_b, clauses_a=None, clauses_b=None):
         "modified_clauses": modified[:50],
         "risk_delta": risk_delta,
         "risk_winner": risk_winner,
+        "comparison_method": comparison_method,
         "type_map_a": {k: len(v) for k, v in type_map_a.items()},
         "type_map_b": {k: len(v) for k, v in type_map_b.items()},
     }
 
+
 def _split_clauses(text):
     """Split text into clauses."""
     text = re.sub(r'\n{3,}', '\n\n', text.strip())
+    # Try section-based splitting first
+    section_splits = re.split(
+        r'(?:\n\n)(?=\d+[.)]\s|\([a-z]\)\s|(?:Section|Article|Clause)\s+\d+)',
+        text
+    )
+    if len(section_splits) >= 3:
+        return [p.strip() for p in section_splits if len(p.strip()) > 30]
+    # Fallback to paragraph/sentence splitting
     parts = re.split(
-        r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n\n)(?=\d+[.)]\s|\([a-z]\)\s|[A-Z][A-Z\s]{2,})',
+        r'(?<=[.!?])\s+(?=[A-Z0-9(])|(?:\n\n)',
         text
     )
     return [p.strip() for p in parts if len(p.strip()) > 30]
 
+
 def render_comparison_html(result):
     """Render comparison results as HTML for Gradio."""
     if "error" in result:
         return f'<p style="color:#dc2626;">{result["error"]}</p>'
 
+    method = result.get("comparison_method", "unknown")
+    method_badge = f'<div style="font-size:10px;color:#6b7280;text-align:center;margin-bottom:12px;">Comparison method: {method}</div>'
+
     html = f'''
     <div style="font-family:system-ui,sans-serif;">
+      {method_badge}
       <div style="display:grid;grid-template-columns:1fr 1fr;gap:12px;margin-bottom:16px;">
         <div style="padding:12px;border-radius:8px;background:#eff6ff;border:1px solid #bfdbfe;text-align:center;">
           <div style="font-size:24px;font-weight:700;color:#1d4ed8;">{result["contract_a_clauses"]}</div>

compliance.py

@@ -1,17 +1,25 @@
 """
-ClauseGuard — Compliance Checker
-════════════════════════════════
-Check contracts against regulatory frameworks:
-  • GDPR (EU General Data Protection Regulation)
-  • CCPA (California Consumer Privacy Act)
-  • SOX (Sarbanes-Oxley)
-  • HIPAA (Health Insurance Portability and Accountability Act)
-  • FINRA (Financial Industry Regulatory Authority)
+ClauseGuard — Compliance Checker v3.0
+═════════════════════════════════════
+FIXED in v3.0:
+  • Negation handling (clause saying "we do NOT" won't score as PASS)
+  • Context windows around keyword matches (shows what the clause actually says)
+  • Semantic scoring (keyword proximity + negation awareness)
+  • Added more regulatory frameworks
 """
 
 import re
 from collections import defaultdict
 
+# Negation patterns that invert compliance meaning
+_NEGATION_PATTERNS = [
+    r"(?:does?\s+)?not\s+(?:require|provide|include|offer|grant|guarantee|ensure|maintain)",
+    r"(?:no|without)\s+(?:obligation|requirement|guarantee|warranty)",
+    r"(?:exclud|waiv|disclaim|exempt|refus|deny|reject)",
+    r"shall\s+not\s+be\s+(?:required|obligated|responsible)",
+    r"is\s+not\s+(?:responsible|liable|required|obligated)",
+]
+
 # Regulatory requirement definitions
 REGULATIONS = {
     "GDPR": {
@@ -47,6 +55,11 @@ REGULATIONS = {
                 "description": "Should reference privacy-by-design principles (Art. 25)",
                 "severity": "MEDIUM",
             },
+            "data_processing_agreement": {
+                "keywords": ["data processing agreement", "DPA", "data processor", "sub-processor"],
+                "description": "Must include data processing agreement if sharing data (Art. 28)",
+                "severity": "HIGH",
+            },
         },
     },
     "CCPA": {
@@ -159,8 +172,40 @@ RISK_STYLES = {
 }
 
 
+def _check_negation(text_lower, keyword, window=100):
+    """Check if a keyword match is negated by nearby negation words."""
+    idx = text_lower.find(keyword.lower())
+    if idx == -1:
+        return False
+    # Get context window around the match
+    start = max(0, idx - window)
+    end = min(len(text_lower), idx + len(keyword) + window)
+    context = text_lower[start:end]
+
+    for neg_pat in _NEGATION_PATTERNS:
+        if re.search(neg_pat, context, re.IGNORECASE):
+            return True
+    return False
+
+
+def _get_context(text, keyword, window=80):
+    """Extract context around a keyword match."""
+    text_lower = text.lower()
+    idx = text_lower.find(keyword.lower())
+    if idx == -1:
+        return ""
+    start = max(0, idx - window)
+    end = min(len(text), idx + len(keyword) + window)
+    context = text[start:end].strip()
+    if start > 0:
+        context = "..." + context
+    if end < len(text):
+        context = context + "..."
+    return context
+
+
 def check_compliance(text):
-    """Check contract text against all regulatory frameworks."""
+    """Check contract text against all regulatory frameworks with negation handling."""
     text_lower = text.lower()
     results = {}
 
@@ -168,28 +213,66 @@ def check_compliance(text):
         checks = []
         for req_name, req_data in reg_data["requirements"].items():
             matched = False
+            negated = False
             matched_keywords = []
+            context_snippets = []
+
             for kw in req_data["keywords"]:
                 if kw.lower() in text_lower:
-                    matched = True
                     matched_keywords.append(kw)
+                    # Check if the match is negated
+                    if _check_negation(text_lower, kw):
+                        negated = True
+                    else:
+                        matched = True
+                    # Get context
+                    ctx = _get_context(text, kw)
+                    if ctx:
+                        context_snippets.append(ctx)
+
+            if matched and not negated:
+                status = "PASS"
+            elif negated and not matched:
+                status = "NEGATED"
+            elif matched and negated:
+                status = "AMBIGUOUS"
+            else:
+                status = "MISSING"
+
             checks.append({
                 "requirement": req_name,
                 "description": req_data["description"],
                 "severity": req_data["severity"],
-                "status": "PASS" if matched else "MISSING",
+                "status": status,
                 "matched_keywords": matched_keywords,
+                "context": context_snippets[:2],  # Keep top 2 context snippets
             })
 
         passed = sum(1 for c in checks if c["status"] == "PASS")
         total = len(checks)
         compliance_rate = round(passed / total * 100) if total > 0 else 0
 
+        negated_count = sum(1 for c in checks if c["status"] == "NEGATED")
+        ambiguous_count = sum(1 for c in checks if c["status"] == "AMBIGUOUS")
+
+        if compliance_rate >= 80:
+            overall = "COMPLIANT"
+        elif compliance_rate >= 40:
+            overall = "PARTIAL"
+        else:
+            overall = "NON-COMPLIANT"
+
+        # Override if there are negated critical requirements
+        if any(c["status"] == "NEGATED" and c["severity"] in ("CRITICAL", "HIGH") for c in checks):
+            overall = "WARNING"
+
         results[reg_name] = {
             "description": reg_data["description"],
             "compliance_rate": compliance_rate,
             "checks": checks,
-            "overall_status": "COMPLIANT" if compliance_rate >= 80 else "PARTIAL" if compliance_rate >= 40 else "NON-COMPLIANT",
+            "overall_status": overall,
+            "negated_count": negated_count,
+            "ambiguous_count": ambiguous_count,
         }
 
     return results
@@ -202,14 +285,29 @@ def render_compliance_html(results):
     for reg_name, reg_result in results.items():
         rate = reg_result["compliance_rate"]
         status = reg_result["overall_status"]
-        status_color = "#16a34a" if status == "COMPLIANT" else "#ca8a04" if status == "PARTIAL" else "#dc2626"
-        status_bg = "#f0fdf4" if status == "COMPLIANT" else "#fefce8" if status == "PARTIAL" else "#fef2f2"
+
+        status_colors = {
+            "COMPLIANT": ("#16a34a", "#f0fdf4"),
+            "PARTIAL": ("#ca8a04", "#fefce8"),
+            "NON-COMPLIANT": ("#dc2626", "#fef2f2"),
+            "WARNING": ("#ea580c", "#fff7ed"),
+        }
+        status_color, status_bg = status_colors.get(status, ("#6b7280", "#f9fafb"))
+
+        neg = reg_result.get("negated_count", 0)
+        amb = reg_result.get("ambiguous_count", 0)
+        warnings = ""
+        if neg > 0:
+            warnings += f'<span style="font-size:10px;color:#ea580c;margin-left:8px;">⚠️ {neg} negated</span>'
+        if amb > 0:
+            warnings += f'<span style="font-size:10px;color:#ca8a04;margin-left:8px;">❓ {amb} ambiguous</span>'
 
         html += f'''
         <div style="border:1px solid #e5e7eb;border-radius:10px;margin-bottom:16px;overflow:hidden;">
           <div style="display:flex;justify-content:space-between;align-items:center;padding:12px 16px;background:{status_bg};border-bottom:1px solid #e5e7eb;">
             <div>
               <span style="font-size:16px;font-weight:700;color:#1f2937;">{reg_name}</span>
+              {warnings}
               <p style="font-size:11px;color:#6b7280;margin:2px 0 0 0;">{reg_result["description"]}</p>
             </div>
             <div style="text-align:right;">
@@ -222,19 +320,27 @@ def render_compliance_html(results):
 
         for check in reg_result["checks"]:
             color, bg = RISK_STYLES[check["severity"]]
-            status_icon = "✅" if check["status"] == "PASS" else "❌"
-            status_text = "Found" if check["status"] == "PASS" else "Missing"
+            status_icons = {"PASS": "✅", "MISSING": "❌", "NEGATED": "🚫", "AMBIGUOUS": "❓"}
+            status_icon = status_icons.get(check["status"], "❓")
+            status_text_map = {"PASS": "Found", "MISSING": "Missing", "NEGATED": "Negated", "AMBIGUOUS": "Ambiguous"}
+            status_text = status_text_map.get(check["status"], "Unknown")
             keywords = ", ".join(check["matched_keywords"][:3]) if check["matched_keywords"] else "—"
 
+            context_html = ""
+            if check.get("context"):
+                ctx = check["context"][0][:120].replace("<", "&lt;").replace(">", "&gt;")
+                context_html = f'<div style="font-size:10px;color:#6b7280;margin-top:2px;font-style:italic;">"{ctx}"</div>'
+
             html += f'''
             <div style="display:flex;justify-content:space-between;align-items:flex-start;padding:8px 0;border-bottom:1px solid #f3f4f6;">
               <div style="flex:1;">
                 <div style="font-size:12px;font-weight:500;color:#374151;">{check["description"]}</div>
                 <div style="font-size:10px;color:#9ca3af;margin-top:2px;">Keywords: {keywords}</div>
+                {context_html}
               </div>
               <div style="display:flex;align-items:center;gap:6px;margin-left:8px;">
                 <span style="font-size:10px;color:{color};font-weight:600;background:{bg};padding:2px 8px;border-radius:4px;">{check["severity"]}</span>
-                <span style="font-size:13px;">{status_icon}</span>
+                <span style="font-size:13px;" title="{status_text}">{status_icon}</span>
               </div>
             </div>
             '''

extension/background.js

@@ -1,20 +1,16 @@
 /**
- * ClauseGuard — Background Service Worker
- * Full website↔extension bridge: auto-detect login, sync user data,
- * save scans to DB, guest mode fallback.
+ * ClauseGuard — Background Service Worker v3.0
+ * FIXED: API payload now sends {text, source_url} (not {clauses})
+ * FIXED: Error handling and retry logic
  */
 
 const API_BASE = "https://gaurv007-clauseguard-api.hf.space";
 const FREE_SCANS_PER_MONTH = 10;
 const API_TIMEOUT_MS = 45000;
 
-// Website URLs (for auth detection)
 const SITE_ORIGINS = [
   "https://clauseguardweb.netlify.app",
-  "https://clauseguardweb.netlify.app",
 ];
-// Add your Netlify URL here after deploy:
-// SITE_ORIGINS.push("https://your-site.netlify.app");
 
 try { chrome.sidePanel.setPanelBehavior({ openPanelOnActionClick: false }); } catch(e) {}
 
@@ -39,7 +35,7 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
       case "CHECK_USAGE": return await checkUsage();
       case "OPEN_SIDEPANEL": if (sender.tab?.id) chrome.sidePanel.open({ tabId: sender.tab.id }); return { ok: true };
       case "GET_RESULTS": return await getStoredResults(sender.tab?.id || message.tabId);
-      case "SYNC_AUTH": return await syncAuthFromWebsite(); // Manual sync trigger
+      case "SYNC_AUTH": return await syncAuthFromWebsite();
       case "GET_SCAN_HISTORY": return await getScanHistory();
       default: return null;
     }
@@ -50,7 +46,6 @@ chrome.runtime.onMessage.addListener((message, sender, sendResponse) => {
 
 // ─── External messages from website ───
 chrome.runtime.onMessageExternal.addListener((message, sender, sendResponse) => {
-  // Accept from any allowed origin (clauseguardweb.netlify.app, netlify, localhost)
   const handle = async () => {
     switch (message.type) {
       case "SET_AUTH": {
@@ -84,12 +79,6 @@ chrome.runtime.onMessageExternal.addListener((message, sender, sendResponse) =>
   return true;
 });
 
-// Auth sync is handled by:
-// 1. Website's ExtensionBridge component sends postMessage on auth change
-// 2. Content script (content.js) picks it up via window.addEventListener("message")
-// 3. Content script writes to chrome.storage.sync
-// No injection needed — this is the reliable path.
-
 // ─── Core: Analyze ───
 async function handleAnalyze(payload, tabId) {
   const usage = await checkUsage();
@@ -98,23 +87,27 @@ async function handleAnalyze(payload, tabId) {
   }
 
   const { text, url } = payload;
-  const clauses = splitIntoClauses(text);
-  if (clauses.length === 0) {
-    return { error: "no_clauses", message: "No analyzable clauses found." };
+  if (!text || text.trim().length < 100) {
+    return { error: "too_short", message: "Not enough text to analyze." };
   }
 
   let results;
   try {
     const auth = await getAuth();
+    // FIXED: Send {text, source_url} not {clauses}
     const resp = await fetchWithTimeout(`${API_BASE}/api/analyze`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         ...(auth.token ? { Authorization: `Bearer ${auth.token}` } : {}),
       },
-      body: JSON.stringify({ clauses, source_url: url }),
+      body: JSON.stringify({ text: text.substring(0, 100000), source_url: url }),
     }, API_TIMEOUT_MS);
 
+    if (resp.status === 429) {
+      return { error: "rate_limited", message: "Too many requests. Please wait a moment." };
+    }
+
     if (!resp.ok) throw new Error(`HTTP ${resp.status}`);
     results = await resp.json();
     results.source = "api";
@@ -127,12 +120,12 @@ async function handleAnalyze(payload, tabId) {
   // Store results
   if (tabId) {
     await chrome.storage.local.set({ [`results_${tabId}`]: results });
-    const flagged = results.results?.filter(r => r.categories?.length > 0).length || 0;
+    const flagged = results.results?.filter(r => r.categories?.length > 0).length || results.flagged_count || 0;
     chrome.action.setBadgeText({ text: flagged > 0 ? String(flagged) : "", tabId });
     if (flagged > 0) chrome.action.setBadgeBackgroundColor({ color: flagged > 3 ? "#ef4444" : "#f59e0b", tabId });
   }
 
-  // Save scan to history (local + server if logged in)
+  // Save scan to history
   const scanRecord = {
     url: url || "",
     risk_score: results.risk_score,
@@ -143,25 +136,23 @@ async function handleAnalyze(payload, tabId) {
     scanned_at: Date.now(),
   };
 
-  // Save to local history (always, even for guests)
   const { scanHistory = [] } = await chrome.storage.local.get("scanHistory");
   scanHistory.unshift(scanRecord);
-  if (scanHistory.length > 50) scanHistory.length = 50; // Keep last 50
+  if (scanHistory.length > 50) scanHistory.length = 50;
   await chrome.storage.local.set({ scanHistory });
 
   await incrementUsage();
   return results;
 }
 
-// ─── Get scan history (for sidepanel) ───
+// ─── Get scan history ───
 async function getScanHistory() {
   const { scanHistory = [] } = await chrome.storage.local.get("scanHistory");
   return { history: scanHistory };
 }
 
-// ─── Sync auth from website (called manually or on install) ───
+// ─── Sync auth from website ───
 async function syncAuthFromWebsite() {
-  // This is triggered by content script when it detects CLAUSEGUARD_AUTH_SYNC message
   return await getAuth();
 }
 

obligations.py

@@ -1,59 +1,65 @@
 """
-ClauseGuard — Obligation Tracker
-═══════════════════════════════
-Extract action items, deadlines, and obligations from contracts.
-Categorize: monetary, compliance, reporting, delivery
+ClauseGuard — Obligation Tracker v3.0
+═════════════════════════════════════
+FIXED in v3.0:
+  • Reduced false positives (filter out generic service descriptions)
+  • Better party extraction with role detection
+  • Obligation priority scoring
+  • Context-aware obligation type detection
 """
 
 import re
 from collections import defaultdict
 from datetime import datetime, timedelta
 
-# Obligation keywords by category
+# Obligation keywords by category — more specific patterns to reduce false positives
 OBLIGATION_PATTERNS = {
     "monetary": [
-        r"(?:shall|must|will|agrees? to)\s+pay\s+(?:\$?[\d,]+(?:\.\d{2})?)",
-        r"(?:fee|payment|compensation|reimburs(?:e|ement))\s+of\s+(?:\$?[\d,]+(?:\.\d{2})?)",
-        r"(?:shall|must|will)\s+remit\s+(?:\$?[\d,]+(?:\.\d{2})?)",
-        r"(?:annual|monthly|quarterly)\s+(?:fee|payment)\s+of",
-        r"(?:liquidated damages|penalty)\s+of\s+(?:\$?[\d,]+(?:\.\d{2})?)",
+        r"(?:shall|must|will|agrees? to)\s+pay\s+(?:a\s+)?(?:(?:monthly|annual|quarterly)\s+)?(?:fee|amount|sum|payment)?\s*(?:of\s+)?(?:\$[\d,]+(?:\.\d{2})?)",
+        r"(?:fee|payment|compensation|reimburs(?:e|ement))\s+(?:of|in the amount of)\s+\$[\d,]+",
+        r"(?:shall|must|will)\s+remit\s+\$[\d,]+",
+        r"(?:liquidated damages|penalty)\s+(?:of|in the amount of)\s+\$[\d,]+",
+        r"(?:shall|must)\s+(?:pay|reimburse)\s+(?:all|any)\s+(?:outstanding|overdue|unpaid)",
     ],
     "compliance": [
-        r"(?:shall|must|will)\s+comply\s+with",
-        r"(?:shall|must|will)\s+adhere\s+to",
-        r"(?:shall|must|will)\s+conform\s+to",
-        r"(?:shall|must|will)\s+follow\s+(?:the|all)\s+(?:applicable|relevant)\s+(?:laws|regulations|standards)",
-        r"(?:GDPR|CCPA|HIPAA|SOX|PCI-DSS|ISO\s+\d+)",
-        r"(?:confidential|privacy|data protection)",
-        r"(?:shall|must|will)\s+obtain\s+(?:necessary|required)\s+(?:approvals?|permits?|licenses?)",
-        r"(?:shall|must|will)\s+maintain\s+(?:insurance|coverage|bond)",
+        r"(?:shall|must|will)\s+comply\s+with\s+(?:all\s+)?(?:applicable\s+)?(?:laws|regulations|standards|requirements)",
+        r"(?:shall|must|will)\s+(?:adhere|conform)\s+to\s+(?:the|all|applicable)",
+        r"(?:shall|must|will)\s+(?:obtain|maintain|procure)\s+(?:all\s+)?(?:necessary|required|applicable)\s+(?:approvals?|permits?|licenses?|certifications?)",
+        r"(?:shall|must|will)\s+maintain\s+(?:insurance|coverage|bond|policy)",
+        r"(?:shall|must|will)\s+ensure\s+(?:compliance|conformance|adherence)",
     ],
     "reporting": [
-        r"(?:shall|must|will)\s+report",
-        r"(?:shall|must|will)\s+provide\s+(?:regular|monthly|quarterly|annual)\s+(?:reports?|updates?|status)",
-        r"(?:shall|must|will)\s+notify",
-        r"(?:shall|must|will)\s+inform",
-        r"(?:shall|must|will)\s+deliver\s+(?:a|an|the)\s+report",
-        r"(?:audit|inspection)\s+(?:reports?|rights?)",
+        r"(?:shall|must|will)\s+(?:report|disclose)\s+(?:to|any)\s+(?:the|supervisory|regulatory)",
+        r"(?:shall|must|will)\s+provide\s+(?:regular|monthly|quarterly|annual|periodic)\s+(?:reports?|updates?|statements?)",
+        r"(?:shall|must|will)\s+(?:notify|inform)\s+(?:the other party|promptly|immediately|within)",
+        r"(?:shall|must|will)\s+deliver\s+(?:a|an|the)\s+(?:report|statement|notice|certificate)",
+        r"(?:shall|must|will)\s+provide\s+(?:SOC|audit|compliance)\s+(?:\d+\s+)?(?:Type\s+)?(?:reports?|certificates?)",
     ],
     "delivery": [
-        r"(?:shall|must|will)\s+deliver",
-        r"(?:shall|must|will)\s+provide",
-        r"(?:shall|must|will)\s+furnish",
-        r"(?:shall|must|will)\s+supply",
-        r"(?:shall|must|will)\s+submit",
-        r"(?:delivery|performance)\s+(?:date|schedule|timeline)",
-        r"(?:within|no later than|by)\s+(?:\d+)\s+(?:days?|weeks?|months?|years?)",
+        r"(?:shall|must|will)\s+deliver\s+(?:the|all|any)\s+(?:products?|goods?|materials?|deliverables?|services?)",
+        r"(?:shall|must|will)\s+(?:furnish|supply)\s+(?:the|all|any)",
+        r"(?:shall|must|will)\s+(?:submit|produce|complete)\s+(?:the|all|any)\s+(?:work|deliverables?|results?)",
+        r"(?:delivery|performance)\s+(?:date|schedule|deadline|timeline|milestone)",
     ],
     "termination": [
-        r"(?:shall|must|will)\s+return",
-        r"(?:shall|must|will)\s+destroy",
-        r"(?:shall|must|will)\s+cease",
-        r"(?:upon|after)\s+termination",
-        r"(?:post-termination|surviving)\s+obligations?",
+        r"(?:shall|must|will)\s+(?:return|surrender)\s+(?:all|any)\s+(?:materials?|property|documents?|data|information|equipment)",
+        r"(?:shall|must|will)\s+(?:destroy|delete|erase)\s+(?:all|any)\s+(?:copies|data|information|records?|materials?)",
+        r"(?:shall|must|will)\s+(?:cease|discontinue)\s+(?:all|any)\s+(?:use|access|activities)",
+        r"(?:upon|after|following)\s+termination.*(?:shall|must|will)\s+(?:pay|return|destroy|cease)",
+        r"(?:surviving|post-termination)\s+obligations?",
     ],
 }
 
+# More restrictive — patterns that DON'T indicate obligations (false positive filters)
+_FALSE_POSITIVE_PATTERNS = [
+    r"^(?:the|this)\s+(?:agreement|contract|document)\s+(?:shall|will)\s+(?:be|become|remain)",
+    r"(?:shall|will)\s+(?:be\s+)?(?:governed|construed|interpreted)",
+    r"(?:shall|will)\s+(?:constitute|represent|mean|include)",
+    r"(?:shall|will)\s+(?:not\s+)?(?:be\s+)?(?:deemed|considered|construed)",
+    r"(?:shall|will)\s+(?:have|possess)\s+(?:the\s+)?(?:right|authority|power)",
+    r"(?:shall|will)\s+(?:survive|remain\s+in\s+(?:effect|force))",
+]
+
 # Timeframe extraction
 TIME_PATTERNS = [
     (r"within\s+(\d+)\s+(day|week|month|year)s?", "relative"),
@@ -62,17 +68,34 @@ TIME_PATTERNS = [
     (r"by\s+([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", "absolute"),
     (r"on\s+or\s+before\s+([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", "absolute"),
     (r"(\d{1,2}/\d{1,2}/\d{2,4})", "absolute_date"),
-    (r"(\d{1,2}-\d{1,2}-\d{2,4})", "absolute_date"),
+    (r"(?:promptly|immediately)(?:\s+(?:upon|after|following))?", "immediate"),
 ]
 
 PARTY_PATTERNS = [
-    r"\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client)\b",
-    r"\b[A-Z][A-Za-z0-9\s&]+(?:Inc\.?|LLC|Ltd\.?|Limited|Corp\.?|Corporation|PLC|GmbH|AG|S\.A\.?|B\.V\.)\b",
+    r"\b(?:Party A|Party B|Disclosing Party|Receiving Party|Licensor|Licensee|Buyer|Seller|Tenant|Landlord|Employer|Employee|Company|Customer|Vendor|Client|Provider|Contractor)\b",
+    r"\b[A-Z][A-Za-z0-9\s&]+?(?:Inc\.?|LLC|Ltd\.?|Limited|Corp\.?|Corporation|PLC|GmbH)\b",
 ]
 
+# Priority scoring for obligation types
+_PRIORITY_MAP = {
+    "monetary": 3,
+    "termination": 3,
+    "compliance": 2,
+    "reporting": 2,
+    "delivery": 1,
+}
+
+
+def _is_false_positive(sentence):
+    """Check if a sentence is a common false positive (definition/interpretation, not obligation)."""
+    for fp in _FALSE_POSITIVE_PATTERNS:
+        if re.search(fp, sentence, re.IGNORECASE):
+            return True
+    return False
+
 
 def extract_obligations(text):
-    """Extract obligations from contract text."""
+    """Extract obligations from contract text with false positive filtering."""
     obligations = []
 
     # Split into sentences
@@ -80,7 +103,11 @@ def extract_obligations(text):
 
     for sentence in sentences:
         sentence = sentence.strip()
-        if len(sentence) < 30:
+        if len(sentence) < 30 or len(sentence) > 1000:
+            continue
+
+        # Skip false positives
+        if _is_false_positive(sentence):
             continue
 
         found_types = set()
@@ -98,11 +125,17 @@ def extract_obligations(text):
         for pp in PARTY_PATTERNS:
             m = re.search(pp, sentence)
             if m:
-                party = m.group(0)
+                party = m.group(0).strip()
                 break
 
+        # Try to determine which party has the obligation based on sentence structure
+        obligation_direction = _detect_obligation_direction(sentence)
+        if obligation_direction:
+            party = obligation_direction
+
         # Extract timeframe
         deadline = "Not specified"
+        deadline_urgency = 0
         for pat, ptype in TIME_PATTERNS:
             m = re.search(pat, sentence, re.IGNORECASE)
             if m:
@@ -110,25 +143,54 @@ def extract_obligations(text):
                     num = m.group(1)
                     unit = m.group(2)
                     deadline = f"Within {num} {unit}(s)"
+                    deadline_urgency = int(num)
                 elif ptype == "business_days":
                     num = m.group(1)
                     deadline = f"Within {num} business day(s)"
+                    deadline_urgency = int(num)
                 elif ptype in ("absolute", "absolute_date"):
                     deadline = m.group(1)
+                    deadline_urgency = 1
+                elif ptype == "immediate":
+                    deadline = "Immediately"
+                    deadline_urgency = 0
                 break
 
         for otype in found_types:
+            priority = _PRIORITY_MAP.get(otype, 1)
+            if deadline_urgency > 0 and deadline_urgency <= 7:
+                priority += 1  # Urgent deadlines get higher priority
+
             obligations.append({
                 "type": otype,
                 "party": party,
                 "description": sentence[:250] + ("..." if len(sentence) > 250 else ""),
                 "deadline": deadline,
                 "full_text": sentence,
+                "priority": priority,
             })
 
+    # Sort by priority (highest first)
+    obligations.sort(key=lambda x: x.get("priority", 0), reverse=True)
+
     return obligations
 
 
+def _detect_obligation_direction(sentence):
+    """Try to detect who bears the obligation from sentence structure."""
+    patterns = [
+        (r"^(?:The\s+)?(Provider|Company|Licensor|Landlord|Employer|Seller|Vendor)\s+(?:shall|must|will)", None),
+        (r"^(?:The\s+)?(Customer|Client|Licensee|Tenant|Employee|Buyer)\s+(?:shall|must|will)", None),
+        (r"^(?:Each|Both)\s+part(?:y|ies)\s+(?:shall|must|will)", "Both parties"),
+        (r"^(?:Neither|No)\s+party\s+(?:shall|may)", "Neither party"),
+    ]
+    for pat, override in patterns:
+        m = re.search(pat, sentence, re.IGNORECASE)
+        if m:
+            return override or m.group(1)
+    return None
+
+
 def render_obligations_html(obligations):
     """Render obligations as HTML cards for Gradio."""
     if not obligations:
@@ -176,10 +238,17 @@ def render_obligations_html(obligations):
         icon = type_icons.get(otype, "📋")
         html += f'<h3 style="font-size:14px;color:#374151;margin:16px 0 8px 0;border-bottom:2px solid {color}30;padding-bottom:4px;">{icon} {otype.title()} Obligations</h3>'
         for ob in obs:
+            priority = ob.get("priority", 1)
+            priority_badge = ""
+            if priority >= 3:
+                priority_badge = '<span style="font-size:9px;background:#fef2f2;color:#dc2626;padding:1px 4px;border-radius:3px;margin-left:4px;">HIGH PRIORITY</span>'
+            elif priority >= 2:
+                priority_badge = '<span style="font-size:9px;background:#fefce8;color:#ca8a04;padding:1px 4px;border-radius:3px;margin-left:4px;">MEDIUM</span>'
+
             html += f'''
             <div style="border:1px solid #e5e7eb;border-left:4px solid {color};border-radius:6px;padding:10px;margin-bottom:8px;background:#fafafa;">
               <div style="display:flex;justify-content:space-between;align-items:center;margin-bottom:4px;">
-                <span style="font-size:12px;font-weight:600;color:{color};">{ob["party"]}</span>
+                <span style="font-size:12px;font-weight:600;color:{color};">{ob["party"]}{priority_badge}</span>
                 <span style="font-size:11px;color:#6b7280;background:#f3f4f6;padding:2px 8px;border-radius:4px;">{ob["deadline"]}</span>
               </div>
               <p style="font-size:12px;color:#4b5563;margin:0;line-height:1.5;">{ob["description"]}</p>

requirements.txt

@@ -4,8 +4,6 @@ torch>=2.5.0
 numpy>=2.0.0
 pdfplumber>=0.11.0
 python-docx>=1.1.0
-spacy>=3.8.0
-scikit-learn>=1.6.0
 peft>=0.15.0
 accelerate>=1.2.0
-pandas>=2.2.0
+sentence-transformers>=3.0.0

web/app/dashboard-pages/analyze/page.tsx

@@ -7,16 +7,18 @@ import {
   ShieldCheck, ShieldAlert, Scale, Gavel, Ban, Globe, Eye, Stamp, FileX,
   Lock, Sparkles as SparklesIcon, X, Layers, Landmark, Briefcase,
   AlertTriangle, Tag, BookOpen, ClipboardList, DollarSign,
-  Calendar, Building, MapPin, Hash
+  Calendar, Building, MapPin, Hash, Bot, FileSearch, Percent, Clock,
+  User, BookMarked, ShieldX, HelpCircle, Cpu, PenTool, Zap,
+  ShieldOff, CircleSlash, MessageSquareWarning, Construction
 } from "lucide-react";
 
 interface Cat { name: string; severity: string; description?: string; confidence?: number; }
 interface Clause { text: string; categories: Cat[]; }
-interface Entity { text: string; type: string; }
-interface Contradiction { type: string; explanation: string; severity: string; }
-interface Obligation { type: string; party: string; description: string; deadline: string; }
-interface ComplianceCheck { requirement: string; description: string; severity: string; status: string; matched_keywords: string[]; }
-interface ComplianceReg { description: string; compliance_rate: number; checks: ComplianceCheck[]; overall_status: string; }
+interface Entity { text: string; type: string; score?: number; source?: string; }
+interface Contradiction { type: string; explanation: string; severity: string; confidence?: number; source?: string; }
+interface Obligation { type: string; party: string; description: string; deadline: string; priority?: number; }
+interface ComplianceCheck { requirement: string; description: string; severity: string; status: string; matched_keywords: string[]; context?: string[]; }
+interface ComplianceReg { description: string; compliance_rate: number; checks: ComplianceCheck[]; overall_status: string; negated_count?: number; ambiguous_count?: number; }
 interface AnalysisResult {
   risk_score: number;
   grade: string;
@@ -31,11 +33,11 @@ interface AnalysisResult {
   latency_ms: number;
 }
 
-const SEV_CONFIG: Record<string, { icon: any; label: string; text: string; bg: string; border: string }> = {
-  CRITICAL: { icon: AlertTriangle, label: "Critical", text: "text-red-700", bg: "bg-red-50", border: "border-red-300" },
-  HIGH: { icon: TriangleAlert, label: "High", text: "text-red-600", bg: "bg-red-50", border: "border-red-200" },
-  MEDIUM: { icon: CircleAlert, label: "Medium", text: "text-amber-600", bg: "bg-amber-50", border: "border-amber-200" },
-  LOW: { icon: Info, label: "Low", text: "text-blue-600", bg: "bg-blue-50", border: "border-blue-200" },
+const SEV_CONFIG: Record<string, { icon: any; label: string; text: string; bg: string; border: string; ring: string }> = {
+  CRITICAL: { icon: AlertTriangle, label: "Critical", text: "text-red-700", bg: "bg-red-50", border: "border-red-300", ring: "ring-red-200" },
+  HIGH: { icon: TriangleAlert, label: "High", text: "text-red-600", bg: "bg-red-50", border: "border-red-200", ring: "ring-red-100" },
+  MEDIUM: { icon: CircleAlert, label: "Medium", text: "text-amber-600", bg: "bg-amber-50", border: "border-amber-200", ring: "ring-amber-100" },
+  LOW: { icon: Info, label: "Low", text: "text-blue-600", bg: "bg-blue-50", border: "border-blue-200", ring: "ring-blue-100" },
 };
 
 const GRADE_STYLE: Record<string, string> = {
@@ -52,32 +54,92 @@ const CATEGORY_ICONS: Record<string, any> = {
   "Choice of law": Gavel, "Contract by using": Stamp, "Uncapped Liability": AlertTriangle,
   "IP Ownership Assignment": Lock, "Non-Compete": Ban, "Governing Law": Gavel,
   "Termination for Convenience": Ban, "Indemnification": ShieldCheck, "Confidentiality": Lock,
+  "Notice Period to Terminate Renewal": Clock, "Cap on Liability": ShieldCheck,
+  "Liquidated Damages": DollarSign, "Force Majeure": Zap,
 };
 
 const ENTITY_COLORS: Record<string, { bg: string; text: string; border: string; icon: any }> = {
   DATE: { bg: "bg-blue-50", text: "text-blue-700", border: "border-blue-200", icon: Calendar },
   DATE_REF: { bg: "bg-blue-50", text: "text-blue-600", border: "border-blue-200", icon: Calendar },
   MONEY: { bg: "bg-emerald-50", text: "text-emerald-700", border: "border-emerald-200", icon: DollarSign },
+  PERCENTAGE: { bg: "bg-teal-50", text: "text-teal-700", border: "border-teal-200", icon: Percent },
+  DURATION: { bg: "bg-indigo-50", text: "text-indigo-700", border: "border-indigo-200", icon: Clock },
   PARTY: { bg: "bg-purple-50", text: "text-purple-700", border: "border-purple-200", icon: Building },
   PARTY_ROLE: { bg: "bg-purple-50", text: "text-purple-600", border: "border-purple-200", icon: Briefcase },
+  PERSON: { bg: "bg-pink-50", text: "text-pink-700", border: "border-pink-200", icon: User },
   JURISDICTION: { bg: "bg-amber-50", text: "text-amber-700", border: "border-amber-200", icon: MapPin },
   DEFINED_TERM: { bg: "bg-pink-50", text: "text-pink-700", border: "border-pink-200", icon: Hash },
+  LEGAL_REF: { bg: "bg-zinc-100", text: "text-zinc-700", border: "border-zinc-200", icon: BookMarked },
+  MISC: { bg: "bg-zinc-50", text: "text-zinc-600", border: "border-zinc-200", icon: Tag },
 };
 
-const OBLIGATION_COLORS: Record<string, { bg: string; text: string; icon: any }> = {
-  monetary: { bg: "bg-emerald-50", text: "text-emerald-700", icon: DollarSign },
-  compliance: { bg: "bg-amber-50", text: "text-amber-700", icon: ShieldCheck },
-  reporting: { bg: "bg-blue-50", text: "text-blue-700", icon: ClipboardList },
-  delivery: { bg: "bg-purple-50", text: "text-purple-700", icon: FileText },
-  termination: { bg: "bg-red-50", text: "text-red-700", icon: Ban },
+const OBLIGATION_COLORS: Record<string, { bg: string; text: string; border: string; icon: any }> = {
+  monetary: { bg: "bg-emerald-50", text: "text-emerald-700", border: "border-emerald-200", icon: DollarSign },
+  compliance: { bg: "bg-amber-50", text: "text-amber-700", border: "border-amber-200", icon: ShieldCheck },
+  reporting: { bg: "bg-blue-50", text: "text-blue-700", border: "border-blue-200", icon: ClipboardList },
+  delivery: { bg: "bg-purple-50", text: "text-purple-700", border: "border-purple-200", icon: FileText },
+  termination: { bg: "bg-red-50", text: "text-red-700", border: "border-red-200", icon: Ban },
 };
 
-const COMPLIANCE_STATUS: Record<string, { bg: string; text: string }> = {
-  COMPLIANT: { bg: "bg-emerald-50", text: "text-emerald-700" },
-  PARTIAL: { bg: "bg-amber-50", text: "text-amber-700" },
-  "NON-COMPLIANT": { bg: "bg-red-50", text: "text-red-700" },
+const COMPLIANCE_STATUS: Record<string, { bg: string; text: string; border: string }> = {
+  COMPLIANT: { bg: "bg-emerald-50", text: "text-emerald-700", border: "border-emerald-200" },
+  PARTIAL: { bg: "bg-amber-50", text: "text-amber-700", border: "border-amber-200" },
+  "NON-COMPLIANT": { bg: "bg-red-50", text: "text-red-700", border: "border-red-200" },
+  WARNING: { bg: "bg-orange-50", text: "text-orange-700", border: "border-orange-200" },
 };
 
+function SourceBadge({ isML, confidence }: { isML: boolean; confidence?: number | null }) {
+  if (isML) {
+    return (
+      <span className="inline-flex items-center gap-1 text-[10px] font-medium bg-indigo-50 text-indigo-600 border border-indigo-200 px-1.5 py-0.5 rounded">
+        <Cpu className="w-2.5 h-2.5" />
+        ML {confidence != null ? `${Math.round(confidence * 100)}%` : ""}
+      </span>
+    );
+  }
+  return (
+    <span className="inline-flex items-center gap-1 text-[10px] font-medium bg-zinc-50 text-zinc-500 border border-zinc-200 px-1.5 py-0.5 rounded">
+      <PenTool className="w-2.5 h-2.5" />
+      Pattern
+    </span>
+  );
+}
+
+function CheckStatusIcon({ status }: { status: string }) {
+  switch (status) {
+    case "PASS": return <CircleCheck className="w-4 h-4 text-emerald-500" />;
+    case "MISSING": return <X className="w-4 h-4 text-red-500" />;
+    case "NEGATED": return <ShieldOff className="w-4 h-4 text-orange-500" />;
+    case "AMBIGUOUS": return <HelpCircle className="w-4 h-4 text-amber-500" />;
+    default: return <CircleAlert className="w-4 h-4 text-zinc-400" />;
+  }
+}
+
+function ContradictionSourceBadge({ source, confidence }: { source?: string; confidence?: number }) {
+  if (source === "nli_model") {
+    return (
+      <span className="inline-flex items-center gap-1 text-[10px] font-medium bg-indigo-50 text-indigo-600 border border-indigo-200 px-1.5 py-0.5 rounded">
+        <Cpu className="w-2.5 h-2.5" />NLI {confidence != null ? `${Math.round(confidence * 100)}%` : ""}
+      </span>
+    );
+  }
+  if (source === "heuristic") {
+    return (
+      <span className="inline-flex items-center gap-1 text-[10px] font-medium bg-amber-50 text-amber-600 border border-amber-200 px-1.5 py-0.5 rounded">
+        <PenTool className="w-2.5 h-2.5" />Heuristic
+      </span>
+    );
+  }
+  if (source === "structural") {
+    return (
+      <span className="inline-flex items-center gap-1 text-[10px] font-medium bg-zinc-50 text-zinc-500 border border-zinc-200 px-1.5 py-0.5 rounded">
+        <Construction className="w-2.5 h-2.5" />Structural
+      </span>
+    );
+  }
+  return null;
+}
+
 const EXAMPLE = `By using the Spotify Service, you agree to be bound by these Terms of Use.
 
 Spotify may, in its sole discretion, modify or update these Terms of Service at any time without prior notice. Your continued use of the Service after any such changes constitutes your acceptance of the new Terms of Service.
@@ -112,13 +174,11 @@ export default function AnalyzePage() {
   async function handleAnalyze() {
     if (!text || text.trim().length < 50) { setError("Enter at least 50 characters."); return; }
     if (!canScan) { setShowUpgrade(true); return; }
-
     setLoading(true); setError(""); setResults(null); setExpandedIdx(null);
     try {
       const res = await fetch("/api/analyze", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ text }) });
       if (!res.ok) throw new Error((await res.json()).error || "Failed");
-      const data = await res.json();
-      setResults(data);
+      setResults(await res.json());
       setScanCount(prev => prev + 1);
     } catch (e: any) { setError(e.message); }
     finally { setLoading(false); }
@@ -128,15 +188,12 @@ export default function AnalyzePage() {
     const file = e.target.files?.[0];
     if (!file) return;
     if (userPlan === "free") { setShowUpgrade(true); return; }
-
     setLoading(true); setError("");
     try {
-      const formData = new FormData();
-      formData.append("file", file);
+      const formData = new FormData(); formData.append("file", file);
       const res = await fetch("/api/parse-upload", { method: "POST", body: formData });
       if (!res.ok) throw new Error((await res.json()).error || "Failed to parse file");
-      const { text: extractedText } = await res.json();
-      setText(extractedText);
+      setText((await res.json()).text);
     } catch (e: any) { setError(e.message || "Could not read file."); }
     setLoading(false);
     if (fileInputRef.current) fileInputRef.current.value = "";
@@ -155,7 +212,7 @@ export default function AnalyzePage() {
 
   function handleCopy() {
     if (!results) return;
-    const summary = `ClauseGuard Report\nRisk: ${results.risk_score}/100 (Grade ${results.grade})\n${results.flagged_count} of ${results.total_clauses} clauses flagged\nEntities: ${results.entities.length} found\nContradictions: ${results.contradictions.length} detected\n\n` +
+    const summary = `ClauseGuard Report\nRisk: ${results.risk_score}/100 (Grade ${results.grade})\n${results.flagged_count} of ${results.total_clauses} clauses flagged\nEntities: ${results.entities.length}\nContradictions: ${results.contradictions.length}\nObligations: ${results.obligations.length}\n\n` +
       results.results.filter(r => r.categories.length > 0).map((r, i) =>
         `${i+1}. [${r.categories.map(c => c.name).join(", ")}] ${r.text.slice(0, 100)}...`
       ).join("\n");
@@ -165,18 +222,15 @@ export default function AnalyzePage() {
 
   const flagged = results?.results.filter(r => r.categories.length > 0) || [];
   const filtered = filter === "all" ? flagged : flagged.filter(r => r.categories.some(c => c.severity === filter));
-
   const sevCounts = { CRITICAL: 0, HIGH: 0, MEDIUM: 0, LOW: 0 };
   flagged.forEach(r => r.categories.forEach(c => { if (sevCounts[c.severity as keyof typeof sevCounts] !== undefined) sevCounts[c.severity as keyof typeof sevCounts]++; }));
 
-  // Group entities by type
-  const entityGroups: Record<string, string[]> = {};
+  const entityGroups: Record<string, Entity[]> = {};
   results?.entities.forEach(e => {
     if (!entityGroups[e.type]) entityGroups[e.type] = [];
-    if (!entityGroups[e.type].includes(e.text)) entityGroups[e.type].push(e.text);
+    if (!entityGroups[e.type].find(x => x.text === e.text)) entityGroups[e.type].push(e);
   });
 
-  // Group obligations by type
   const obligationGroups: Record<string, Obligation[]> = {};
   results?.obligations.forEach(o => {
     if (!obligationGroups[o.type]) obligationGroups[o.type] = [];
@@ -184,18 +238,19 @@ export default function AnalyzePage() {
   });
 
   const tabs = [
-    { key: "clauses", label: "Clauses", icon: Layers },
-    { key: "entities", label: "Entities", icon: Tag },
-    { key: "contradictions", label: "Contradictions", icon: AlertTriangle },
-    { key: "obligations", label: "Obligations", icon: ClipboardList },
-    { key: "compliance", label: "Compliance", icon: ShieldCheck },
+    { key: "clauses", label: "Clauses", icon: Layers, count: flagged.length },
+    { key: "entities", label: "Entities", icon: Tag, count: results?.entities.length || 0 },
+    { key: "contradictions", label: "Issues", icon: AlertTriangle, count: results?.contradictions.length || 0 },
+    { key: "obligations", label: "Obligations", icon: ClipboardList, count: results?.obligations.length || 0 },
+    { key: "compliance", label: "Compliance", icon: ShieldCheck, count: Object.keys(results?.compliance || {}).length },
   ];
 
   return (
-    <div className="min-h-screen bg-white">
+    <div className="min-h-screen bg-zinc-50/30">
+      {/* Upgrade Modal */}
       {showUpgrade && (
-        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40">
-          <div className="bg-white rounded-2xl p-6 max-w-sm mx-4 shadow-xl">
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/40 px-4">
+          <div className="bg-white rounded-2xl p-6 max-w-sm w-full shadow-2xl">
             <div className="flex justify-between items-start">
               <div className="w-10 h-10 rounded-xl bg-amber-50 flex items-center justify-center"><Lock className="w-5 h-5 text-amber-600" /></div>
               <button onClick={() => setShowUpgrade(false)} className="p-1 hover:bg-zinc-100 rounded-md"><X className="w-4 h-4 text-zinc-400" /></button>
@@ -203,8 +258,8 @@ export default function AnalyzePage() {
             <h3 className="mt-4 text-lg font-semibold">{userPlan === "free" && scanCount >= FREE_LIMIT ? "Free limit reached" : "Pro feature"}</h3>
             <p className="mt-1.5 text-sm text-zinc-500 leading-relaxed">
               {userPlan === "free" && scanCount >= FREE_LIMIT
-                ? `You have used all ${FREE_LIMIT} free scans. Upgrade to Pro for unlimited scans, file uploads, and full analysis.`
-                : "File upload is available on the Pro plan. Upgrade to scan contracts and leases directly."}
+                ? `You have used all ${FREE_LIMIT} free scans. Upgrade to Pro for unlimited scans and full analysis.`
+                : "File upload is available on the Pro plan."}
             </p>
             <div className="mt-5 flex gap-2">
               <a href="/#pricing" className="flex-1 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium text-center hover:bg-zinc-800 transition-colors">View plans</a>
@@ -214,73 +269,96 @@ export default function AnalyzePage() {
         </div>
       )}
 
-      <div className="max-w-7xl mx-auto px-5 py-10">
-        <div className="mb-8 flex items-start justify-between">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6 sm:py-10">
+        {/* Header */}
+        <div className="mb-6 sm:mb-8 flex flex-col sm:flex-row sm:items-start sm:justify-between gap-3">
           <div>
-            <h1 className="text-2xl font-semibold tracking-tight flex items-center gap-2">
-              <ScanText className="w-6 h-6 text-zinc-400" />
+            <h1 className="text-xl sm:text-2xl font-semibold tracking-tight flex items-center gap-2">
+              <ScanText className="w-5 h-5 sm:w-6 sm:h-6 text-zinc-400" />
               Scan a document
             </h1>
-            <p className="mt-1 text-sm text-zinc-500">Paste text or upload a file (.pdf, .docx, .txt). Get 41-category clause detection, risk scoring, NER, compliance, and more.</p>
+            <p className="mt-1 text-xs sm:text-sm text-zinc-500 max-w-xl">Paste text or upload a file. Get 41-category clause detection, risk scoring, ML NER, NLI contradictions, compliance checks, and obligation tracking.</p>
           </div>
           {userPlan === "free" && (
-            <span className="text-xs text-zinc-400 border border-zinc-200 px-2.5 py-1 rounded-md">{scanCount}/{FREE_LIMIT} free scans</span>
+            <span className="self-start text-xs text-zinc-400 border border-zinc-200 px-2.5 py-1 rounded-md whitespace-nowrap">{scanCount}/{FREE_LIMIT} free scans</span>
           )}
         </div>
 
-        <div className="grid lg:grid-cols-5 gap-6">
-          {/* Input */}
+        <div className="grid lg:grid-cols-5 gap-4 sm:gap-6">
+          {/* Input Panel */}
           <div className="lg:col-span-2">
-            <textarea value={text} onChange={(e) => setText(e.target.value)}
-              placeholder="Paste your contract or terms text here..."
-              className="w-full h-[380px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
-            <div className="mt-3 flex gap-2">
-              <button onClick={handleAnalyze} disabled={loading}
-                className="flex-1 inline-flex items-center justify-center gap-2 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 disabled:opacity-40 transition-colors">
-                {loading ? <><ScanLine className="w-4 h-4 animate-pulse" /> Analyzing...</> : <><ScanText className="w-4 h-4" /> Analyze</>}
-              </button>
-              <button onClick={() => setText(EXAMPLE)} className="px-3 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">Example</button>
-              <input ref={fileInputRef} type="file" accept=".txt,.md,.pdf,.docx" className="hidden" onChange={handleFileUpload} />
-              <button onClick={() => fileInputRef.current?.click()} className="px-3 border border-zinc-200 rounded-lg text-zinc-500 hover:bg-zinc-50 transition-colors" title="Upload file"><Upload className="w-4 h-4" /></button>
+            <div className="bg-white border border-zinc-200 rounded-xl p-3 sm:p-4">
+              <textarea value={text} onChange={(e) => setText(e.target.value)}
+                placeholder="Paste your contract or terms text here..."
+                className="w-full h-[260px] sm:h-[360px] p-3 border border-zinc-100 rounded-lg text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono bg-zinc-50/50" />
+              <div className="mt-3 flex gap-2">
+                <button onClick={handleAnalyze} disabled={loading}
+                  className="flex-1 inline-flex items-center justify-center gap-2 bg-zinc-900 text-white py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 disabled:opacity-40 transition-colors">
+                  {loading ? <><ScanLine className="w-4 h-4 animate-pulse" /> Analyzing...</> : <><ScanText className="w-4 h-4" /> Analyze</>}
+                </button>
+                <button onClick={() => setText(EXAMPLE)} className="px-3 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">Example</button>
+                <input ref={fileInputRef} type="file" accept=".txt,.md,.pdf,.docx" className="hidden" onChange={handleFileUpload} />
+                <button onClick={() => fileInputRef.current?.click()} className="px-3 border border-zinc-200 rounded-lg text-zinc-500 hover:bg-zinc-50 transition-colors" title="Upload file"><Upload className="w-4 h-4" /></button>
+              </div>
             </div>
             {error && <p className="mt-2 text-sm text-red-600 flex items-center gap-1.5"><TriangleAlert className="w-3.5 h-3.5" />{error}</p>}
           </div>
 
-          {/* Results */}
+          {/* Results Panel */}
           <div className="lg:col-span-3">
             {results ? (
-              <div className="space-y-4">
-                {/* Score card */}
-                <div className="border border-zinc-200 rounded-xl p-5">
-                  <div className="flex items-start justify-between">
+              <div className="space-y-3 sm:space-y-4">
+                {/* Score Card */}
+                <div className="bg-white border border-zinc-200 rounded-xl p-4 sm:p-5">
+                  <div className="flex flex-col sm:flex-row sm:items-start sm:justify-between gap-3">
                     <div>
                       <div className="flex items-baseline gap-2">
-                        <span className="text-4xl font-semibold tracking-tight">{results.risk_score}</span>
+                        <span className="text-3xl sm:text-4xl font-semibold tracking-tight">{results.risk_score}</span>
                         <span className="text-sm text-zinc-400">/100 risk</span>
                       </div>
-                      <div className="mt-2 h-1.5 w-48 bg-zinc-100 rounded-full overflow-hidden">
+                      <div className="mt-2 h-1.5 w-full sm:w-48 bg-zinc-100 rounded-full overflow-hidden">
                         <div className={`h-full rounded-full transition-all duration-700 ${
                           results.risk_score >= 60 ? "bg-red-500" : results.risk_score >= 30 ? "bg-amber-400" : "bg-emerald-500"
                         }`} style={{ width: `${results.risk_score}%` }} />
                       </div>
                     </div>
-                    <span className={`text-sm font-semibold px-3 py-1 rounded-lg border ${GRADE_STYLE[results.grade] || GRADE_STYLE.C}`}>
+                    <span className={`self-start text-sm font-semibold px-3 py-1 rounded-lg border ${GRADE_STYLE[results.grade] || GRADE_STYLE.C}`}>
                       Grade {results.grade}
                     </span>
                   </div>
-                  <div className="mt-4 flex items-center gap-4 text-xs text-zinc-400">
-                    <span>{results.total_clauses} clauses</span><span className="w-px h-3 bg-zinc-200" />
-                    <span>{results.flagged_count} flagged</span><span className="w-px h-3 bg-zinc-200" />
-                    <span>{results.entities.length} entities</span><span className="w-px h-3 bg-zinc-200" />
-                    <span>{results.contradictions.length} issues</span><span className="w-px h-3 bg-zinc-200" />
-                    <span>{results.latency_ms}ms</span><span className="w-px h-3 bg-zinc-200" />
-                    <span className="flex items-center gap-1">{results.model !== "regex" && <SparklesIcon className="w-3 h-3" />}{results.model !== "regex" ? "Legal-BERT v2" : "Pattern fallback"}</span>
+
+                  {/* Severity breakdown grid */}
+                  <div className="mt-4 grid grid-cols-4 gap-2">
+                    {(["CRITICAL", "HIGH", "MEDIUM", "LOW"] as const).map(sev => {
+                      const c = SEV_CONFIG[sev];
+                      return (
+                        <div key={sev} className={`text-center p-2 rounded-lg ${c.bg} border ${c.border}`}>
+                          <span className={`text-lg font-bold ${c.text}`}>{sevCounts[sev]}</span>
+                          <p className={`text-[10px] ${c.text} opacity-70`}>{c.label}</p>
+                        </div>
+                      );
+                    })}
+                  </div>
+
+                  {/* Meta stats */}
+                  <div className="mt-3 flex items-center gap-2 sm:gap-3 text-[11px] text-zinc-400 flex-wrap">
+                    <span className="flex items-center gap-1"><Layers className="w-3 h-3" />{results.total_clauses} clauses</span>
+                    <span className="w-px h-3 bg-zinc-200" />
+                    <span className="flex items-center gap-1"><Tag className="w-3 h-3" />{results.entities.length} entities</span>
+                    <span className="w-px h-3 bg-zinc-200" />
+                    <span className="flex items-center gap-1"><ClipboardList className="w-3 h-3" />{results.obligations.length} obligations</span>
+                    <span className="w-px h-3 bg-zinc-200" />
+                    <span className="flex items-center gap-1"><Clock className="w-3 h-3" />{results.latency_ms}ms</span>
+                    <span className="w-px h-3 bg-zinc-200" />
+                    <span className="flex items-center gap-1">
+                      {results.model !== "regex" ? <><Cpu className="w-3 h-3" /> ML Models</> : <><FileSearch className="w-3 h-3" /> Pattern fallback</>}
+                    </span>
                   </div>
                 </div>
 
-                {/* Filter + Actions */}
-                <div className="flex items-center justify-between">
-                  <div className="flex gap-1">
+                {/* Filter + Actions bar */}
+                <div className="flex flex-col sm:flex-row sm:items-center sm:justify-between gap-2">
+                  <div className="flex gap-1 overflow-x-auto pb-1">
                     {[
                       { key: "all", label: "All", count: flagged.length },
                       { key: "CRITICAL", label: "Critical", count: sevCounts.CRITICAL },
@@ -289,12 +367,12 @@ export default function AnalyzePage() {
                       { key: "LOW", label: "Low", count: sevCounts.LOW },
                     ].map((f) => (
                       <button key={f.key} onClick={() => setFilter(f.key)}
-                        className={`px-3 py-1.5 text-xs font-medium rounded-md transition-colors ${filter === f.key ? "bg-zinc-900 text-white" : "text-zinc-500 hover:bg-zinc-100"}`}>
+                        className={`px-3 py-1.5 text-xs font-medium rounded-md transition-colors whitespace-nowrap ${filter === f.key ? "bg-zinc-900 text-white" : "text-zinc-500 hover:bg-zinc-100"}`}>
                         {f.label} {f.count > 0 && <span className="ml-1 opacity-60">{f.count}</span>}
                       </button>
                     ))}
                   </div>
-                  <div className="flex gap-1.5">
+                  <div className="flex gap-1.5 self-end sm:self-auto">
                     <button onClick={handleCopy} className="p-2 rounded-md hover:bg-zinc-100 text-zinc-400 hover:text-zinc-600 transition-colors" title="Copy summary">
                       {copied ? <Check className="w-4 h-4 text-emerald-500" /> : <Copy className="w-4 h-4" />}
                     </button>
@@ -303,26 +381,28 @@ export default function AnalyzePage() {
                 </div>
 
                 {/* Tabs */}
-                <div className="border-b border-zinc-200">
-                  <div className="flex gap-1">
+                <div className="border-b border-zinc-200 overflow-x-auto">
+                  <div className="flex gap-0.5 min-w-max">
                     {tabs.map((t) => (
                       <button key={t.key} onClick={() => setActiveTab(t.key)}
-                        className={`flex items-center gap-1.5 px-3 py-2 text-sm font-medium border-b-2 transition-colors ${
+                        className={`flex items-center gap-1.5 px-3 py-2 text-xs sm:text-sm font-medium border-b-2 transition-colors whitespace-nowrap ${
                           activeTab === t.key ? "border-zinc-900 text-zinc-900" : "border-transparent text-zinc-400 hover:text-zinc-600"
                         }`}>
-                        <t.icon className="w-4 h-4" />{t.label}
+                        <t.icon className="w-3.5 h-3.5" />{t.label}
+                        {t.count > 0 && <span className="text-[10px] bg-zinc-100 text-zinc-500 px-1.5 py-0.5 rounded-full">{t.count}</span>}
                       </button>
                     ))}
                   </div>
                 </div>
 
                 {/* Tab Content */}
-                <div className="max-h-[420px] overflow-y-auto pr-1">
-                  {/* Clauses Tab */}
+                <div className="max-h-[350px] sm:max-h-[420px] overflow-y-auto pr-1">
+
+                  {/* Clauses */}
                   {activeTab === "clauses" && (
                     <div className="space-y-2">
                       {filtered.length === 0 ? (
-                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-8 sm:p-10 text-center bg-white">
                           <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
                           <p className="text-sm text-zinc-500">{filter === "all" ? "No flagged clauses found." : "No clauses at this severity."}</p>
                         </div>
@@ -335,35 +415,39 @@ export default function AnalyzePage() {
                         const isExpanded = expandedIdx === i;
                         const CatIcon = CATEGORY_ICONS[clause.categories[0]?.name] || Layers;
                         return (
-                          <div key={i} className={`border rounded-xl overflow-hidden transition-all ${conf.border} ${isExpanded ? "shadow-sm" : ""}`}>
-                            <button onClick={() => setExpandedIdx(isExpanded ? null : i)} className="w-full text-left p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
+                          <div key={i} className={`bg-white border rounded-xl overflow-hidden transition-all ${conf.border} ${isExpanded ? "shadow-md ring-1 " + conf.ring : "hover:shadow-sm"}`}>
+                            <button onClick={() => setExpandedIdx(isExpanded ? null : i)} className="w-full text-left p-3 sm:p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
                               <div className={`w-8 h-8 rounded-lg flex items-center justify-center shrink-0 ${conf.bg}`}>
                                 <CatIcon className={`w-4 h-4 ${conf.text}`} />
                               </div>
                               <div className="flex-1 min-w-0">
-                                <div className="flex items-center gap-2 flex-wrap">
+                                <div className="flex items-center gap-1.5 flex-wrap">
                                   {clause.categories.map((cat, j) => {
                                     const s = SEV_CONFIG[cat.severity] || SEV_CONFIG.MEDIUM;
                                     return (
-                                      <span key={j} className={`text-[11px] font-medium px-2 py-0.5 rounded border ${s.bg} ${s.text} ${s.border}`}>
-                                        {cat.name}{cat.confidence ? ` ${Math.round(cat.confidence * 100)}%` : ""}
+                                      <span key={j} className={`inline-flex items-center gap-1 text-[11px] font-medium px-2 py-0.5 rounded border ${s.bg} ${s.text} ${s.border}`}>
+                                        {cat.name}
                                       </span>
                                     );
                                   })}
+                                  <SourceBadge isML={clause.categories[0]?.confidence != null} confidence={clause.categories[0]?.confidence} />
                                 </div>
                                 <p className="mt-1.5 text-sm text-zinc-600 leading-relaxed line-clamp-2">{clause.text}</p>
                               </div>
                               <div className="shrink-0 mt-1">{isExpanded ? <ChevronUp className="w-4 h-4 text-zinc-400" /> : <ChevronDown className="w-4 h-4 text-zinc-400" />}</div>
                             </button>
                             {isExpanded && (
-                              <div className="px-4 pb-4 pt-0 border-t border-zinc-100">
-                                <p className="text-sm text-zinc-700 leading-relaxed mt-3 font-mono bg-zinc-50 rounded-lg p-3">{clause.text}</p>
+                              <div className="px-3 sm:px-4 pb-4 pt-0 border-t border-zinc-100">
+                                <p className="text-sm text-zinc-700 leading-relaxed mt-3 font-mono bg-zinc-50 rounded-lg p-3 break-words">{clause.text}</p>
                                 {clause.categories.map((cat, j) => (
                                   <div key={j} className="mt-3 flex items-start gap-2">
                                     <TriangleAlert className={`w-3.5 h-3.5 mt-0.5 shrink-0 ${(SEV_CONFIG[cat.severity] || SEV_CONFIG.MEDIUM).text}`} />
-                                    <p className="text-[13px] text-zinc-500 leading-relaxed">
+                                    <div className="text-[13px] text-zinc-500 leading-relaxed">
                                       <span className="font-medium text-zinc-700">{cat.name}:</span> {cat.description || "This clause may contain risks. Review carefully."}
-                                    </p>
+                                      <div className="mt-1">
+                                        <SourceBadge isML={cat.confidence != null} confidence={cat.confidence} />
+                                      </div>
+                                    </div>
                                   </div>
                                 ))}
                               </div>
@@ -374,28 +458,33 @@ export default function AnalyzePage() {
                     </div>
                   )}
 
-                  {/* Entities Tab */}
+                  {/* Entities */}
                   {activeTab === "entities" && (
                     <div className="space-y-4">
                       {Object.keys(entityGroups).length === 0 ? (
-                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-8 sm:p-10 text-center bg-white">
                           <Tag className="w-8 h-8 text-zinc-300 mx-auto mb-2" />
                           <p className="text-sm text-zinc-500">No entities detected.</p>
                         </div>
                       ) : Object.entries(entityGroups).map(([type, items]) => {
-                        const cfg = ENTITY_COLORS[type] || { bg: "bg-zinc-50", text: "text-zinc-700", border: "border-zinc-200", icon: Tag };
+                        const cfg = ENTITY_COLORS[type] || ENTITY_COLORS.MISC;
                         const Icon = cfg.icon;
+                        const hasML = items.some(e => e.source === "ml");
                         return (
-                          <div key={type}>
-                            <div className="flex items-center gap-2 mb-2">
-                              <Icon className={`w-4 h-4 ${cfg.text}`} />
-                              <span className="text-sm font-medium text-zinc-700">{type.replace("_", " ")}</span>
-                              <span className="text-xs text-zinc-400">({items.length})</span>
+                          <div key={type} className="bg-white border border-zinc-200 rounded-xl p-3 sm:p-4">
+                            <div className="flex items-center gap-2 mb-2.5">
+                              <div className={`w-6 h-6 rounded flex items-center justify-center ${cfg.bg}`}>
+                                <Icon className={`w-3.5 h-3.5 ${cfg.text}`} />
+                              </div>
+                              <span className="text-sm font-medium text-zinc-700">{type.replace(/_/g, " ")}</span>
+                              <span className="text-[11px] text-zinc-400 bg-zinc-100 px-1.5 py-0.5 rounded">{items.length}</span>
+                              {hasML && <SourceBadge isML={true} />}
                             </div>
-                            <div className="flex flex-wrap gap-2">
-                              {items.slice(0, 20).map((item, i) => (
-                                <span key={i} className={`inline-flex items-center px-2.5 py-1 rounded-md text-xs font-medium ${cfg.bg} ${cfg.text} border ${cfg.border}`}>
-                                  {item}
+                            <div className="flex flex-wrap gap-1.5">
+                              {items.slice(0, 25).map((item, i) => (
+                                <span key={i} className={`inline-flex items-center px-2.5 py-1 rounded-md text-xs font-medium ${cfg.bg} ${cfg.text} border ${cfg.border}`}
+                                  title={item.score ? `Confidence: ${Math.round(item.score * 100)}%` : item.source || ""}>
+                                  {item.text}
                                 </span>
                               ))}
                             </div>
@@ -405,100 +494,153 @@ export default function AnalyzePage() {
                     </div>
                   )}
 
-                  {/* Contradictions Tab */}
+                  {/* Contradictions */}
                   {activeTab === "contradictions" && (
                     <div className="space-y-2">
                       {results.contradictions.length === 0 ? (
-                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-8 sm:p-10 text-center bg-white">
                           <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
                           <p className="text-sm text-zinc-500">No contradictions or missing clauses detected.</p>
                         </div>
                       ) : results.contradictions.map((c, i) => {
                         const conf = SEV_CONFIG[c.severity] || SEV_CONFIG.MEDIUM;
                         return (
-                          <div key={i} className={`border rounded-xl p-4 ${conf.border} ${conf.bg}`}>
-                            <div className="flex items-center gap-2 mb-2">
+                          <div key={i} className={`bg-white border rounded-xl p-3 sm:p-4 ${conf.border}`}>
+                            <div className="flex items-center gap-2 mb-2 flex-wrap">
                               <conf.icon className={`w-4 h-4 ${conf.text}`} />
                               <span className={`text-xs font-semibold uppercase ${conf.text}`}>{c.type}</span>
+                              <ContradictionSourceBadge source={c.source} confidence={c.confidence} />
                             </div>
-                            <p className="text-sm text-zinc-700">{c.explanation}</p>
+                            <p className="text-sm text-zinc-700 leading-relaxed">{c.explanation}</p>
                           </div>
                         );
                       })}
                     </div>
                   )}
 
-                  {/* Obligations Tab */}
+                  {/* Obligations */}
                   {activeTab === "obligations" && (
                     <div className="space-y-4">
                       {Object.keys(obligationGroups).length === 0 ? (
-                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-8 sm:p-10 text-center bg-white">
                           <ClipboardList className="w-8 h-8 text-zinc-300 mx-auto mb-2" />
                           <p className="text-sm text-zinc-500">No obligations detected.</p>
                         </div>
-                      ) : Object.entries(obligationGroups).map(([type, items]) => {
-                        const cfg = OBLIGATION_COLORS[type] || { bg: "bg-zinc-50", text: "text-zinc-700", icon: ClipboardList };
-                        const Icon = cfg.icon;
-                        return (
-                          <div key={type}>
-                            <div className="flex items-center gap-2 mb-2">
-                              <Icon className={`w-4 h-4 ${cfg.text}`} />
-                              <span className="text-sm font-medium capitalize text-zinc-700">{type} Obligations</span>
-                              <span className="text-xs text-zinc-400">({items.length})</span>
-                            </div>
-                            <div className="space-y-2">
-                              {items.map((o, i) => (
-                                <div key={i} className="border border-zinc-200 rounded-lg p-3">
-                                  <div className="flex items-center justify-between mb-1">
-                                    <span className="text-xs font-medium text-zinc-600">{o.party}</span>
-                                    <span className="text-[11px] text-zinc-400 bg-zinc-100 px-2 py-0.5 rounded">{o.deadline}</span>
-                                  </div>
-                                  <p className="text-sm text-zinc-600">{o.description}</p>
+                      ) : (
+                        <>
+                          {/* Summary cards */}
+                          <div className="grid grid-cols-2 sm:grid-cols-3 lg:grid-cols-5 gap-2">
+                            {Object.entries(obligationGroups).map(([type, items]) => {
+                              const cfg = OBLIGATION_COLORS[type] || OBLIGATION_COLORS.compliance;
+                              const Icon = cfg.icon;
+                              return (
+                                <div key={type} className={`text-center p-3 rounded-xl ${cfg.bg} border ${cfg.border}`}>
+                                  <Icon className={`w-5 h-5 mx-auto ${cfg.text}`} />
+                                  <span className={`text-lg font-bold ${cfg.text}`}>{items.length}</span>
+                                  <p className={`text-[10px] capitalize ${cfg.text} opacity-70`}>{type}</p>
                                 </div>
-                              ))}
-                            </div>
+                              );
+                            })}
                           </div>
-                        );
-                      })}
+                          {/* Individual obligations */}
+                          {Object.entries(obligationGroups).map(([type, items]) => {
+                            const cfg = OBLIGATION_COLORS[type] || OBLIGATION_COLORS.compliance;
+                            const Icon = cfg.icon;
+                            return (
+                              <div key={type}>
+                                <div className="flex items-center gap-2 mb-2">
+                                  <Icon className={`w-4 h-4 ${cfg.text}`} />
+                                  <span className="text-sm font-medium capitalize text-zinc-700">{type}</span>
+                                  <span className="text-[11px] text-zinc-400 bg-zinc-100 px-1.5 py-0.5 rounded">{items.length}</span>
+                                </div>
+                                <div className="space-y-2">
+                                  {items.map((o, i) => (
+                                    <div key={i} className="bg-white border border-zinc-200 rounded-lg p-3">
+                                      <div className="flex items-center justify-between mb-1 gap-2 flex-wrap">
+                                        <div className="flex items-center gap-2">
+                                          <span className="text-xs font-medium text-zinc-600">{o.party}</span>
+                                          {o.priority != null && o.priority >= 3 && (
+                                            <span className="inline-flex items-center gap-1 text-[9px] bg-red-50 text-red-600 border border-red-200 px-1.5 py-0.5 rounded font-semibold">
+                                              <AlertTriangle className="w-2.5 h-2.5" />HIGH
+                                            </span>
+                                          )}
+                                          {o.priority != null && o.priority === 2 && (
+                                            <span className="inline-flex items-center gap-1 text-[9px] bg-amber-50 text-amber-600 border border-amber-200 px-1.5 py-0.5 rounded font-semibold">
+                                              <CircleAlert className="w-2.5 h-2.5" />MED
+                                            </span>
+                                          )}
+                                        </div>
+                                        <span className="text-[11px] text-zinc-400 bg-zinc-100 px-2 py-0.5 rounded flex items-center gap-1">
+                                          <Clock className="w-3 h-3" />{o.deadline}
+                                        </span>
+                                      </div>
+                                      <p className="text-sm text-zinc-600 leading-relaxed">{o.description}</p>
+                                    </div>
+                                  ))}
+                                </div>
+                              </div>
+                            );
+                          })}
+                        </>
+                      )}
                     </div>
                   )}
 
-                  {/* Compliance Tab */}
+                  {/* Compliance */}
                   {activeTab === "compliance" && (
                     <div className="space-y-4">
                       {Object.keys(results.compliance).length === 0 ? (
-                        <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
+                        <div className="border border-dashed border-zinc-200 rounded-xl p-8 sm:p-10 text-center bg-white">
                           <ShieldCheck className="w-8 h-8 text-zinc-300 mx-auto mb-2" />
                           <p className="text-sm text-zinc-500">No compliance data available.</p>
                         </div>
                       ) : Object.entries(results.compliance).map(([regName, reg]) => {
                         const status = COMPLIANCE_STATUS[reg.overall_status] || COMPLIANCE_STATUS.PARTIAL;
                         return (
-                          <div key={regName} className="border border-zinc-200 rounded-xl overflow-hidden">
-                            <div className="flex items-center justify-between p-4 border-b border-zinc-100 bg-zinc-50/50">
+                          <div key={regName} className="bg-white border border-zinc-200 rounded-xl overflow-hidden">
+                            <div className={`flex flex-col sm:flex-row sm:items-center justify-between p-4 border-b ${status.bg} ${status.border}`}>
                               <div>
-                                <span className="text-sm font-semibold text-zinc-900">{regName}</span>
+                                <div className="flex items-center gap-2 flex-wrap">
+                                  <span className="text-sm font-semibold text-zinc-900">{regName}</span>
+                                  {(reg.negated_count ?? 0) > 0 && (
+                                    <span className="inline-flex items-center gap-1 text-[9px] bg-orange-50 text-orange-600 border border-orange-200 px-1.5 py-0.5 rounded font-medium">
+                                      <ShieldOff className="w-2.5 h-2.5" />{reg.negated_count} negated
+                                    </span>
+                                  )}
+                                  {(reg.ambiguous_count ?? 0) > 0 && (
+                                    <span className="inline-flex items-center gap-1 text-[9px] bg-amber-50 text-amber-600 border border-amber-200 px-1.5 py-0.5 rounded font-medium">
+                                      <HelpCircle className="w-2.5 h-2.5" />{reg.ambiguous_count} ambiguous
+                                    </span>
+                                  )}
+                                </div>
                                 <p className="text-[11px] text-zinc-500 mt-0.5">{reg.description}</p>
                               </div>
-                              <div className="text-right">
+                              <div className="text-left sm:text-right mt-2 sm:mt-0">
                                 <span className={`text-lg font-bold ${status.text}`}>{reg.compliance_rate}%</span>
                                 <span className={`text-[11px] font-medium block ${status.text}`}>{reg.overall_status}</span>
                               </div>
                             </div>
-                            <div className="p-3 space-y-1">
+                            <div className="p-3 space-y-0.5">
                               {reg.checks.map((check, i) => {
                                 const sev = SEV_CONFIG[check.severity] || SEV_CONFIG.MEDIUM;
                                 return (
-                                  <div key={i} className="flex items-center justify-between py-2 px-2 hover:bg-zinc-50 rounded-md">
-                                    <div className="flex-1 min-w-0">
-                                      <p className="text-xs text-zinc-600">{check.description}</p>
-                                      {check.matched_keywords.length > 0 && (
-                                        <p className="text-[10px] text-zinc-400 mt-0.5">Matched: {check.matched_keywords.slice(0, 3).join(", ")}</p>
-                                      )}
-                                    </div>
-                                    <div className="flex items-center gap-2 ml-3">
-                                      <span className={`text-[10px] font-semibold px-1.5 py-0.5 rounded ${sev.bg} ${sev.text}`}>{check.severity}</span>
-                                      <span className="text-sm">{check.status === "PASS" ? "✅" : "❌"}</span>
+                                  <div key={i} className="py-2.5 px-2 hover:bg-zinc-50 rounded-lg transition-colors">
+                                    <div className="flex items-start justify-between gap-2">
+                                      <div className="flex-1 min-w-0">
+                                        <p className="text-xs text-zinc-600 leading-relaxed">{check.description}</p>
+                                        {check.matched_keywords.length > 0 && (
+                                          <p className="text-[10px] text-zinc-400 mt-0.5">Matched: {check.matched_keywords.slice(0, 3).join(", ")}</p>
+                                        )}
+                                        {check.context && check.context.length > 0 && (
+                                          <p className="text-[10px] text-zinc-400 mt-1 italic border-l-2 border-zinc-200 pl-2 line-clamp-2">
+                                            {check.context[0].slice(0, 120)}
+                                          </p>
+                                        )}
+                                      </div>
+                                      <div className="flex items-center gap-2 ml-2 shrink-0">
+                                        <span className={`text-[10px] font-semibold px-1.5 py-0.5 rounded ${sev.bg} ${sev.text}`}>{check.severity}</span>
+                                        <CheckStatusIcon status={check.status} />
+                                      </div>
                                     </div>
                                   </div>
                                 );
@@ -512,7 +654,7 @@ export default function AnalyzePage() {
                 </div>
               </div>
             ) : (
-              <div className="border border-dashed border-zinc-200 rounded-xl h-[420px] flex flex-col items-center justify-center">
+              <div className="bg-white border border-dashed border-zinc-200 rounded-xl h-[300px] sm:h-[420px] flex flex-col items-center justify-center">
                 <ScanText className="w-10 h-10 text-zinc-200 mb-3" />
                 <p className="text-sm text-zinc-300">Paste text and analyze to see results</p>
               </div>

web/app/dashboard-pages/compare/page.tsx

@@ -4,7 +4,7 @@ import { useState } from "react";
 import {
   GitCompare, ArrowRightLeft, ChevronDown, ChevronUp,
   TriangleAlert, CircleCheck, AlertTriangle,
-  Loader2
+  Loader2, Cpu, FileSearch, Layers, Scale
 } from "lucide-react";
 
 interface CompareResult {
@@ -16,6 +16,7 @@ interface CompareResult {
   modified_clauses: Array<{ type: string; similarity: number; clause_a: string; clause_b: string; clause_type: string }>;
   risk_delta: string;
   risk_winner: string;
+  comparison_method?: string;
   type_map_a: Record<string, number>;
   type_map_b: Record<string, number>;
 }
@@ -60,147 +61,136 @@ export default function ComparePage() {
   async function handleCompare() {
     if (!textA.trim() || textA.trim().length < 50) { setError("Contract A must have at least 50 characters."); return; }
     if (!textB.trim() || textB.trim().length < 50) { setError("Contract B must have at least 50 characters."); return; }
-
     setLoading(true); setError(""); setResult(null); setExpandedIdx(null);
     try {
-      const res = await fetch("/api/compare", {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ text_a: textA, text_b: textB }),
-      });
+      const res = await fetch("/api/compare", { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ text_a: textA, text_b: textB }) });
       if (!res.ok) throw new Error((await res.json()).error || "Failed");
-      const data = await res.json();
-      setResult(data);
+      setResult(await res.json());
     } catch (e: any) { setError(e.message); }
     finally { setLoading(false); }
   }
 
-  function loadExamples() {
-    setTextA(EXAMPLE_A);
-    setTextB(EXAMPLE_B);
-  }
-
   return (
-    <div className="min-h-screen bg-white">
-      <div className="max-w-7xl mx-auto px-5 py-10">
-        <div className="mb-8">
-          <h1 className="text-2xl font-semibold tracking-tight flex items-center gap-2">
-            <GitCompare className="w-6 h-6 text-zinc-400" />
+    <div className="min-h-screen bg-zinc-50/30">
+      <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6 sm:py-10">
+        <div className="mb-6 sm:mb-8">
+          <h1 className="text-xl sm:text-2xl font-semibold tracking-tight flex items-center gap-2">
+            <GitCompare className="w-5 h-5 sm:w-6 sm:h-6 text-zinc-400" />
             Compare Contracts
           </h1>
-          <p className="mt-1 text-sm text-zinc-500">Upload or paste two contracts side-by-side. Get clause-level diffs, alignment score, and risk delta.</p>
+          <p className="mt-1 text-xs sm:text-sm text-zinc-500">Side-by-side semantic diff with clause-level alignment and risk delta.</p>
         </div>
 
-        {/* Input area */}
-        <div className="grid lg:grid-cols-2 gap-4 mb-6">
-          <div>
-            <label className="text-sm font-medium text-zinc-700 mb-1.5 flex items-center gap-2">
-              <span className="w-6 h-6 rounded bg-zinc-100 flex items-center justify-center text-xs font-bold text-zinc-600">A</span>
-              Contract A
-            </label>
-            <textarea value={textA} onChange={(e) => setTextA(e.target.value)}
-              placeholder="Paste contract A here..."
-              className="w-full h-[280px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
-          </div>
-          <div>
-            <label className="text-sm font-medium text-zinc-700 mb-1.5 flex items-center gap-2">
-              <span className="w-6 h-6 rounded bg-zinc-100 flex items-center justify-center text-xs font-bold text-zinc-600">B</span>
-              Contract B
-            </label>
-            <textarea value={textB} onChange={(e) => setTextB(e.target.value)}
-              placeholder="Paste contract B here..."
-              className="w-full h-[280px] p-4 border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
-          </div>
+        {/* Input */}
+        <div className="grid md:grid-cols-2 gap-4 mb-6">
+          {[
+            { label: "A", value: textA, setValue: setTextA },
+            { label: "B", value: textB, setValue: setTextB },
+          ].map(({ label, value, setValue }) => (
+            <div key={label}>
+              <label className="text-sm font-medium text-zinc-700 mb-1.5 flex items-center gap-2">
+                <span className="w-6 h-6 rounded bg-zinc-100 flex items-center justify-center text-xs font-bold text-zinc-600">{label}</span>
+                Contract {label}
+              </label>
+              <textarea value={value} onChange={(e) => setValue(e.target.value)}
+                placeholder={`Paste contract ${label} here...`}
+                className="w-full h-[200px] sm:h-[280px] p-3 sm:p-4 bg-white border border-zinc-200 rounded-xl text-sm leading-relaxed resize-none focus:outline-none focus:ring-2 focus:ring-zinc-900/10 focus:border-zinc-300 placeholder:text-zinc-300 font-mono" />
+            </div>
+          ))}
         </div>
 
         <div className="flex gap-2 mb-8">
           <button onClick={handleCompare} disabled={loading}
             className="inline-flex items-center gap-2 bg-zinc-900 text-white px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 disabled:opacity-40 transition-colors">
-            {loading ? <><Loader2 className="w-4 h-4 animate-spin" /> Comparing...</> : <><ArrowRightLeft className="w-4 h-4" /> Compare Contracts</>}
+            {loading ? <><Loader2 className="w-4 h-4 animate-spin" /> Comparing...</> : <><ArrowRightLeft className="w-4 h-4" /> Compare</>}
           </button>
-          <button onClick={loadExamples} className="px-4 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">Load Example</button>
+          <button onClick={() => { setTextA(EXAMPLE_A); setTextB(EXAMPLE_B); }} className="px-4 border border-zinc-200 rounded-lg text-sm text-zinc-500 hover:bg-zinc-50 transition-colors">Load Example</button>
         </div>
 
         {error && <p className="mb-6 text-sm text-red-600 flex items-center gap-1.5"><TriangleAlert className="w-3.5 h-3.5" />{error}</p>}
 
-        {/* Results */}
         {result && (
-          <div className="space-y-6">
-            {/* Summary */}
-            <div className="grid md:grid-cols-4 gap-4">
-              <div className="border border-zinc-200 rounded-xl p-4 text-center">
-                <p className="text-xs text-zinc-400">Alignment</p>
+          <div className="space-y-4 sm:space-y-6">
+            {/* Method indicator */}
+            {result.comparison_method && (
+              <div className="flex items-center justify-center gap-2 text-xs text-zinc-400">
+                {result.comparison_method.includes("semantic") ? <Cpu className="w-3.5 h-3.5" /> : <FileSearch className="w-3.5 h-3.5" />}
+                <span>Method: {result.comparison_method}</span>
+              </div>
+            )}
+
+            {/* Summary grid */}
+            <div className="grid grid-cols-2 md:grid-cols-4 gap-3">
+              <div className="bg-white border border-zinc-200 rounded-xl p-4 text-center">
+                <Layers className="w-5 h-5 text-blue-500 mx-auto mb-1" />
                 <p className="text-2xl font-bold text-zinc-900">{(result.alignment_score * 100).toFixed(1)}%</p>
+                <p className="text-[11px] text-zinc-400">Alignment</p>
               </div>
-              <div className="border border-zinc-200 rounded-xl p-4 text-center">
-                <p className="text-xs text-zinc-400">Clauses in A</p>
+              <div className="bg-white border border-zinc-200 rounded-xl p-4 text-center">
+                <p className="text-[11px] text-zinc-400 mb-1">Contract A</p>
                 <p className="text-2xl font-bold text-zinc-900">{result.contract_a_clauses}</p>
+                <p className="text-[11px] text-zinc-400">clauses</p>
               </div>
-              <div className="border border-zinc-200 rounded-xl p-4 text-center">
-                <p className="text-xs text-zinc-400">Clauses in B</p>
+              <div className="bg-white border border-zinc-200 rounded-xl p-4 text-center">
+                <p className="text-[11px] text-zinc-400 mb-1">Contract B</p>
                 <p className="text-2xl font-bold text-zinc-900">{result.contract_b_clauses}</p>
+                <p className="text-[11px] text-zinc-400">clauses</p>
               </div>
               <div className={`border rounded-xl p-4 text-center ${result.risk_winner === "tie" ? "border-emerald-200 bg-emerald-50" : "border-red-200 bg-red-50"}`}>
-                <p className="text-xs text-zinc-400">Risk Winner</p>
-                <p className={`text-sm font-bold ${result.risk_winner === "tie" ? "text-emerald-700" : "text-red-700"}`}>{result.risk_delta}</p>
+                <Scale className={`w-5 h-5 mx-auto mb-1 ${result.risk_winner === "tie" ? "text-emerald-500" : "text-red-500"}`} />
+                <p className={`text-sm font-bold leading-tight ${result.risk_winner === "tie" ? "text-emerald-700" : "text-red-700"}`}>{result.risk_delta}</p>
               </div>
             </div>
 
-            {/* Section tabs */}
-            <div className="border-b border-zinc-200">
-              <div className="flex gap-1">
+            {/* Tabs */}
+            <div className="border-b border-zinc-200 overflow-x-auto">
+              <div className="flex gap-0.5 min-w-max">
                 {[
-                  { key: "summary", label: "Summary", count: 0 },
+                  { key: "summary", label: "Summary" },
                   { key: "modified", label: "Modified", count: result.modified_clauses.length },
                   { key: "added", label: "Added in B", count: result.added_clauses.length },
                   { key: "removed", label: "Removed from A", count: result.removed_clauses.length },
                 ].map((s) => (
                   <button key={s.key} onClick={() => setActiveSection(s.key)}
-                    className={`px-3 py-2 text-sm font-medium border-b-2 transition-colors ${activeSection === s.key ? "border-zinc-900 text-zinc-900" : "border-transparent text-zinc-400 hover:text-zinc-600"}`}>
-                    {s.label} {s.count > 0 && <span className="ml-1 text-zinc-400">({s.count})</span>}
+                    className={`px-3 py-2 text-xs sm:text-sm font-medium border-b-2 transition-colors whitespace-nowrap ${activeSection === s.key ? "border-zinc-900 text-zinc-900" : "border-transparent text-zinc-400 hover:text-zinc-600"}`}>
+                    {s.label} {s.count != null && s.count > 0 && <span className="ml-1 text-zinc-400 bg-zinc-100 px-1.5 py-0.5 rounded-full text-[10px]">{s.count}</span>}
                   </button>
                 ))}
               </div>
             </div>
 
-            {/* Section content */}
-            <div className="max-h-[500px] overflow-y-auto">
-              {/* Modified clauses */}
+            {/* Content */}
+            <div className="max-h-[400px] sm:max-h-[500px] overflow-y-auto">
               {activeSection === "modified" && (
                 <div className="space-y-3">
                   {result.modified_clauses.length === 0 ? (
-                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
-                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
-                      <p className="text-sm text-zinc-500">No modified clauses detected.</p>
-                    </div>
+                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center bg-white"><CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" /><p className="text-sm text-zinc-500">No modified clauses.</p></div>
                   ) : result.modified_clauses.map((m, i) => {
                     const isExpanded = expandedIdx === i;
-                    const simColor = m.similarity >= 0.8 ? "text-emerald-600" : m.similarity >= 0.6 ? "text-amber-600" : "text-red-600";
+                    const simColor = m.similarity >= 0.8 ? "text-emerald-600 bg-emerald-50" : m.similarity >= 0.6 ? "text-amber-600 bg-amber-50" : "text-red-600 bg-red-50";
                     return (
-                      <div key={i} className="border border-zinc-200 rounded-xl overflow-hidden">
-                        <button onClick={() => setExpandedIdx(isExpanded ? null : i)} className="w-full text-left p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
-                          <div className="w-8 h-8 rounded-lg bg-amber-50 flex items-center justify-center shrink-0">
-                            <AlertTriangle className="w-4 h-4 text-amber-600" />
-                          </div>
+                      <div key={i} className="bg-white border border-zinc-200 rounded-xl overflow-hidden">
+                        <button onClick={() => setExpandedIdx(isExpanded ? null : i)} className="w-full text-left p-3 sm:p-4 flex items-start gap-3 hover:bg-zinc-50/50 transition-colors">
+                          <div className="w-8 h-8 rounded-lg bg-amber-50 flex items-center justify-center shrink-0"><AlertTriangle className="w-4 h-4 text-amber-600" /></div>
                           <div className="flex-1 min-w-0">
-                            <div className="flex items-center gap-2">
+                            <div className="flex items-center gap-2 flex-wrap">
                               <span className="text-xs font-medium text-zinc-500 uppercase">{m.clause_type}</span>
-                              <span className={`text-xs font-bold ${simColor}`}>{(m.similarity * 100).toFixed(0)}% similar</span>
+                              <span className={`text-xs font-bold px-2 py-0.5 rounded ${simColor}`}>{(m.similarity * 100).toFixed(0)}% similar</span>
                             </div>
-                            <p className="mt-1 text-sm text-zinc-600 line-clamp-2">{m.clause_a}...</p>
+                            <p className="mt-1 text-sm text-zinc-600 line-clamp-2">{m.clause_a}</p>
                           </div>
                           <div className="shrink-0 mt-1">{isExpanded ? <ChevronUp className="w-4 h-4 text-zinc-400" /> : <ChevronDown className="w-4 h-4 text-zinc-400" />}</div>
                         </button>
                         {isExpanded && (
-                          <div className="px-4 pb-4 pt-0 border-t border-zinc-100">
-                            <div className="grid grid-cols-2 gap-3 mt-3">
-                              <div className="bg-red-50 rounded-lg p-3">
-                                <p className="text-[10px] font-semibold text-red-600 uppercase mb-1">Contract A</p>
-                                <p className="text-sm text-zinc-700">{m.clause_a}</p>
+                          <div className="px-3 sm:px-4 pb-4 pt-0 border-t border-zinc-100">
+                            <div className="grid grid-cols-1 sm:grid-cols-2 gap-3 mt-3">
+                              <div className="bg-red-50 rounded-lg p-3 border border-red-100">
+                                <p className="text-[10px] font-semibold text-red-600 uppercase mb-1.5">Contract A</p>
+                                <p className="text-sm text-zinc-700 leading-relaxed">{m.clause_a}</p>
                               </div>
-                              <div className="bg-emerald-50 rounded-lg p-3">
-                                <p className="text-[10px] font-semibold text-emerald-600 uppercase mb-1">Contract B</p>
-                                <p className="text-sm text-zinc-700">{m.clause_b}</p>
+                              <div className="bg-emerald-50 rounded-lg p-3 border border-emerald-100">
+                                <p className="text-[10px] font-semibold text-emerald-600 uppercase mb-1.5">Contract B</p>
+                                <p className="text-sm text-zinc-700 leading-relaxed">{m.clause_b}</p>
                               </div>
                             </div>
                           </div>
@@ -211,66 +201,49 @@ export default function ComparePage() {
                 </div>
               )}
 
-              {/* Added clauses */}
               {activeSection === "added" && (
                 <div className="space-y-2">
                   {result.added_clauses.length === 0 ? (
-                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
-                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
-                      <p className="text-sm text-zinc-500">No new clauses added in Contract B.</p>
-                    </div>
+                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center bg-white"><CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" /><p className="text-sm text-zinc-500">No new clauses in B.</p></div>
                   ) : result.added_clauses.map((c, i) => (
-                    <div key={i} className="border-l-4 border-emerald-400 bg-emerald-50/30 rounded-r-xl p-3">
+                    <div key={i} className="bg-white border-l-4 border-emerald-400 border border-zinc-200 rounded-r-xl p-3">
                       <span className="text-[10px] font-semibold text-emerald-600 uppercase">{c.type}</span>
-                      <p className="text-sm text-zinc-700 mt-1">{c.text}</p>
+                      <p className="text-sm text-zinc-700 mt-1 leading-relaxed">{c.text}</p>
                     </div>
                   ))}
                 </div>
               )}
 
-              {/* Removed clauses */}
               {activeSection === "removed" && (
                 <div className="space-y-2">
                   {result.removed_clauses.length === 0 ? (
-                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center">
-                      <CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" />
-                      <p className="text-sm text-zinc-500">No clauses removed from Contract A.</p>
-                    </div>
+                    <div className="border border-dashed border-zinc-200 rounded-xl p-10 text-center bg-white"><CircleCheck className="w-8 h-8 text-emerald-400 mx-auto mb-2" /><p className="text-sm text-zinc-500">No clauses removed.</p></div>
                   ) : result.removed_clauses.map((c, i) => (
-                    <div key={i} className="border-l-4 border-red-400 bg-red-50/30 rounded-r-xl p-3">
+                    <div key={i} className="bg-white border-l-4 border-red-400 border border-zinc-200 rounded-r-xl p-3">
                       <span className="text-[10px] font-semibold text-red-600 uppercase">{c.type}</span>
-                      <p className="text-sm text-zinc-700 mt-1">{c.text}</p>
+                      <p className="text-sm text-zinc-700 mt-1 leading-relaxed">{c.text}</p>
                     </div>
                   ))}
                 </div>
               )}
 
-              {/* Summary */}
               {activeSection === "summary" && (
                 <div className="space-y-4">
-                  <div className="grid grid-cols-2 gap-4">
-                    <div className="border border-zinc-200 rounded-xl p-4">
-                      <p className="text-xs font-medium text-zinc-500 mb-2">Contract A Clause Types</p>
-                      {Object.entries(result.type_map_a).map(([type, count]) => (
-                        <div key={type} className="flex justify-between text-sm py-1">
-                          <span className="text-zinc-600 capitalize">{type}</span>
-                          <span className="font-medium text-zinc-900">{count}</span>
-                        </div>
-                      ))}
-                    </div>
-                    <div className="border border-zinc-200 rounded-xl p-4">
-                      <p className="text-xs font-medium text-zinc-500 mb-2">Contract B Clause Types</p>
-                      {Object.entries(result.type_map_b).map(([type, count]) => (
-                        <div key={type} className="flex justify-between text-sm py-1">
-                          <span className="text-zinc-600 capitalize">{type}</span>
-                          <span className="font-medium text-zinc-900">{count}</span>
-                        </div>
-                      ))}
-                    </div>
-                  </div>
-                  <div className="border border-zinc-200 rounded-xl p-4">
-                    <p className="text-xs font-medium text-zinc-500 mb-2">Raw JSON</p>
-                    <pre className="text-xs text-zinc-600 overflow-x-auto bg-zinc-50 rounded-lg p-3">{JSON.stringify(result, null, 2)}</pre>
+                  <div className="grid grid-cols-1 sm:grid-cols-2 gap-4">
+                    {[
+                      { label: "Contract A Clause Types", data: result.type_map_a },
+                      { label: "Contract B Clause Types", data: result.type_map_b },
+                    ].map(({ label, data }) => (
+                      <div key={label} className="bg-white border border-zinc-200 rounded-xl p-4">
+                        <p className="text-xs font-medium text-zinc-500 mb-2">{label}</p>
+                        {Object.entries(data).map(([type, count]) => (
+                          <div key={type} className="flex justify-between text-sm py-1 border-b border-zinc-50 last:border-0">
+                            <span className="text-zinc-600 capitalize">{type}</span>
+                            <span className="font-medium text-zinc-900">{count}</span>
+                          </div>
+                        ))}
+                      </div>
+                    ))}
                   </div>
                 </div>
               )}

web/app/dashboard-pages/dashboard/page.tsx

@@ -1,8 +1,8 @@
 import { createClient } from "@/lib/supabase/server";
 import Link from "next/link";
 import {
-  ScanText, ShieldCheck, TriangleAlert, Tag, AlertTriangle,
-  ClipboardList, GitCompare, TrendingUp, Clock
+  ScanText, ShieldCheck, Tag, AlertTriangle, ClipboardList,
+  GitCompare, Cpu, Layers, Clock
 } from "lucide-react";
 
 export default async function DashboardPage() {
@@ -10,180 +10,162 @@ export default async function DashboardPage() {
   const { data: { user } } = await supabase.auth.getUser();
 
   const { data: profile } = await supabase
-    .from("profiles")
-    .select("*")
-    .eq("id", user?.id)
-    .single();
+    .from("profiles").select("*").eq("id", user?.id).single();
 
   const { data: analyses, count } = await supabase
-    .from("analyses")
-    .select("*", { count: "exact" })
-    .eq("user_id", user?.id)
-    .order("created_at", { ascending: false })
-    .limit(10);
+    .from("analyses").select("*", { count: "exact" }).eq("user_id", user?.id)
+    .order("created_at", { ascending: false }).limit(10);
 
   const plan = profile?.plan || "free";
   const usedThisMonth = profile?.analyses_this_month || 0;
-  const limit = plan === "free" ? 10 : "∞";
+  const limit = plan === "free" ? 10 : "Unlimited";
 
-  // Calculate stats
   const avgRisk = analyses && analyses.length > 0
-    ? Math.round(analyses.reduce((s, a) => s + a.risk_score, 0) / analyses.length)
+    ? Math.round(analyses.reduce((s: number, a: any) => s + a.risk_score, 0) / analyses.length)
     : null;
-
-  const totalEntities = analyses?.reduce((s, a) => s + (a.entities?.length || 0), 0) || 0;
-  const totalContradictions = analyses?.reduce((s, a) => s + (a.contradictions?.length || 0), 0) || 0;
-  const totalObligations = analyses?.reduce((s, a) => s + (a.obligations?.length || 0), 0) || 0;
+  const totalEntities = analyses?.reduce((s: number, a: any) => s + (a.entities?.length || 0), 0) || 0;
+  const totalContradictions = analyses?.reduce((s: number, a: any) => s + (a.contradictions?.length || 0), 0) || 0;
+  const totalObligations = analyses?.reduce((s: number, a: any) => s + (a.obligations?.length || 0), 0) || 0;
 
   return (
-    <div className="min-h-screen bg-gray-50">
-      <div className="max-w-6xl mx-auto px-6 py-12">
+    <div className="min-h-screen bg-zinc-50/30">
+      <div className="max-w-6xl mx-auto px-4 sm:px-6 py-8 sm:py-12">
         {/* Header */}
-        <div className="flex justify-between items-center mb-10">
+        <div className="flex flex-col sm:flex-row justify-between items-start sm:items-center gap-4 mb-8 sm:mb-10">
           <div>
-            <h1 className="text-2xl font-bold text-gray-900">🛡️ Dashboard</h1>
-            <p className="text-gray-500 text-sm mt-1">
-              Welcome back, {profile?.full_name || user?.email}
-            </p>
+            <h1 className="text-xl sm:text-2xl font-bold text-gray-900 flex items-center gap-2">
+              <ShieldCheck className="w-5 h-5 sm:w-6 sm:h-6 text-indigo-500" />
+              Dashboard
+            </h1>
+            <p className="text-gray-500 text-sm mt-1">Welcome back, {profile?.full_name || user?.email}</p>
           </div>
-          <Link
-            href="/dashboard-pages/analyze"
-            className="bg-indigo-600 text-white px-6 py-3 rounded-xl font-semibold hover:bg-indigo-700 transition text-sm"
-          >
+          <Link href="/dashboard-pages/analyze"
+            className="bg-indigo-600 text-white px-5 sm:px-6 py-2.5 sm:py-3 rounded-xl font-semibold hover:bg-indigo-700 transition text-sm whitespace-nowrap">
             + New Scan
           </Link>
         </div>
 
-        {/* Stats */}
-        <div className="grid md:grid-cols-2 lg:grid-cols-4 gap-6 mb-10">
-          <div className="bg-white rounded-xl p-6 border border-gray-200">
-            <p className="text-sm text-gray-500">Plan</p>
-            <p className="text-2xl font-bold text-gray-900 capitalize mt-1">{plan}</p>
-          </div>
-          <div className="bg-white rounded-xl p-6 border border-gray-200">
-            <p className="text-sm text-gray-500">Scans This Month</p>
-            <p className="text-2xl font-bold text-gray-900 mt-1">{usedThisMonth} / {limit}</p>
-          </div>
-          <div className="bg-white rounded-xl p-6 border border-gray-200">
-            <p className="text-sm text-gray-500">Total Scans</p>
-            <p className="text-2xl font-bold text-gray-900 mt-1">{count || 0}</p>
-          </div>
-          <div className="bg-white rounded-xl p-6 border border-gray-200">
-            <p className="text-sm text-gray-500">Avg Risk Score</p>
-            <p className="text-2xl font-bold text-gray-900 mt-1">{avgRisk !== null ? avgRisk : "—"}</p>
-          </div>
+        {/* Primary Stats */}
+        <div className="grid grid-cols-2 lg:grid-cols-4 gap-3 sm:gap-6 mb-8 sm:mb-10">
+          {[
+            { label: "Plan", value: plan, capitalize: true },
+            { label: "Scans This Month", value: `${usedThisMonth} / ${limit}` },
+            { label: "Total Scans", value: String(count || 0) },
+            { label: "Avg Risk Score", value: avgRisk !== null ? String(avgRisk) : "\u2014" },
+          ].map((s) => (
+            <div key={s.label} className="bg-white rounded-xl p-4 sm:p-6 border border-gray-200">
+              <p className="text-xs sm:text-sm text-gray-500">{s.label}</p>
+              <p className={`text-xl sm:text-2xl font-bold text-gray-900 mt-1 ${s.capitalize ? "capitalize" : ""}`}>{s.value}</p>
+            </div>
+          ))}
         </div>
 
-        {/* Extended Stats v2 */}
-        <div className="grid md:grid-cols-3 gap-6 mb-10">
-          <div className="bg-white rounded-xl p-6 border border-gray-200 flex items-center gap-4">
-            <div className="w-10 h-10 rounded-lg bg-blue-50 flex items-center justify-center">
-              <Tag className="w-5 h-5 text-blue-600" />
-            </div>
-            <div>
-              <p className="text-sm text-gray-500">Entities Extracted</p>
-              <p className="text-xl font-bold text-gray-900">{totalEntities}</p>
-            </div>
-          </div>
-          <div className="bg-white rounded-xl p-6 border border-gray-200 flex items-center gap-4">
-            <div className="w-10 h-10 rounded-lg bg-amber-50 flex items-center justify-center">
-              <AlertTriangle className="w-5 h-5 text-amber-600" />
-            </div>
-            <div>
-              <p className="text-sm text-gray-500">Contradictions Found</p>
-              <p className="text-xl font-bold text-gray-900">{totalContradictions}</p>
-            </div>
-          </div>
-          <div className="bg-white rounded-xl p-6 border border-gray-200 flex items-center gap-4">
-            <div className="w-10 h-10 rounded-lg bg-emerald-50 flex items-center justify-center">
-              <ClipboardList className="w-5 h-5 text-emerald-600" />
-            </div>
-            <div>
-              <p className="text-sm text-gray-500">Obligations Tracked</p>
-              <p className="text-xl font-bold text-gray-900">{totalObligations}</p>
+        {/* Analysis Stats */}
+        <div className="grid grid-cols-1 sm:grid-cols-3 gap-3 sm:gap-6 mb-8 sm:mb-10">
+          {[
+            { icon: Tag, label: "Entities Extracted", value: totalEntities, sublabel: "via Legal-BERT NER", color: "bg-blue-50 text-blue-600" },
+            { icon: AlertTriangle, label: "Contradictions Found", value: totalContradictions, sublabel: "via DeBERTa NLI model", color: "bg-amber-50 text-amber-600" },
+            { icon: ClipboardList, label: "Obligations Tracked", value: totalObligations, sublabel: "with priority scoring", color: "bg-emerald-50 text-emerald-600" },
+          ].map((s) => (
+            <div key={s.label} className="bg-white rounded-xl p-4 sm:p-6 border border-gray-200 flex items-center gap-4">
+              <div className={`w-10 h-10 rounded-lg flex items-center justify-center ${s.color.split(" ")[0]}`}>
+                <s.icon className={`w-5 h-5 ${s.color.split(" ")[1]}`} />
+              </div>
+              <div>
+                <p className="text-xs sm:text-sm text-gray-500">{s.label}</p>
+                <p className="text-lg sm:text-xl font-bold text-gray-900">{s.value}</p>
+                <p className="text-[10px] text-gray-400">{s.sublabel}</p>
+              </div>
             </div>
-          </div>
+          ))}
         </div>
 
         {/* Quick Actions */}
-        <div className="grid md:grid-cols-2 gap-6 mb-10">
-          <Link href="/dashboard-pages/analyze" className="bg-white rounded-xl p-6 border border-gray-200 hover:border-indigo-200 hover:shadow-sm transition-all group">
+        <div className="grid sm:grid-cols-2 gap-3 sm:gap-6 mb-8 sm:mb-10">
+          <Link href="/dashboard-pages/analyze" className="bg-white rounded-xl p-5 sm:p-6 border border-gray-200 hover:border-indigo-200 hover:shadow-sm transition-all group">
             <div className="flex items-center gap-3 mb-2">
               <div className="w-10 h-10 rounded-lg bg-indigo-50 flex items-center justify-center group-hover:bg-indigo-100 transition-colors">
                 <ScanText className="w-5 h-5 text-indigo-600" />
               </div>
               <h3 className="font-semibold text-gray-900">Analyze Contract</h3>
             </div>
-            <p className="text-sm text-gray-500">Scan a contract for 41 clause types, risk scoring, NER, and compliance.</p>
+            <p className="text-sm text-gray-500">Scan with 3 ML models: clause classifier, Legal NER, and NLI contradiction detection.</p>
           </Link>
-          <Link href="/dashboard-pages/compare" className="bg-white rounded-xl p-6 border border-gray-200 hover:border-indigo-200 hover:shadow-sm transition-all group">
+          <Link href="/dashboard-pages/compare" className="bg-white rounded-xl p-5 sm:p-6 border border-gray-200 hover:border-indigo-200 hover:shadow-sm transition-all group">
             <div className="flex items-center gap-3 mb-2">
               <div className="w-10 h-10 rounded-lg bg-indigo-50 flex items-center justify-center group-hover:bg-indigo-100 transition-colors">
                 <GitCompare className="w-5 h-5 text-indigo-600" />
               </div>
               <h3 className="font-semibold text-gray-900">Compare Contracts</h3>
             </div>
-            <p className="text-sm text-gray-500">Side-by-side diff with alignment scoring and risk delta analysis.</p>
+            <p className="text-sm text-gray-500">Side-by-side diff with semantic similarity scoring and risk delta.</p>
           </Link>
         </div>
 
         {/* Recent Scans */}
         <div className="bg-white rounded-xl border border-gray-200 overflow-hidden">
-          <div className="px-6 py-4 border-b border-gray-100">
+          <div className="px-4 sm:px-6 py-4 border-b border-gray-100">
             <h2 className="font-semibold text-gray-900">Recent Scans</h2>
           </div>
           {analyses && analyses.length > 0 ? (
             <div className="divide-y divide-gray-100">
-              {analyses.map((a) => (
-                <div key={a.id} className="px-6 py-4 flex items-center justify-between hover:bg-gray-50">
+              {analyses.map((a: any) => (
+                <div key={a.id} className="px-4 sm:px-6 py-4 flex flex-col sm:flex-row sm:items-center justify-between hover:bg-gray-50 gap-2 sm:gap-4">
                   <div className="flex-1 min-w-0">
-                    <p className="text-sm font-medium text-gray-900 truncate">
-                      {a.source_url || "Manual scan"}
-                    </p>
-                    <div className="flex items-center gap-3 mt-1">
+                    <p className="text-sm font-medium text-gray-900 truncate">{a.source_url || "Manual scan"}</p>
+                    <div className="flex items-center gap-2 mt-1 flex-wrap">
                       <p className="text-xs text-gray-500">
                         {new Date(a.created_at).toLocaleDateString()} · {a.total_clauses} clauses · {a.flagged_count} flagged
                       </p>
                       {a.entities && a.entities.length > 0 && (
-                        <span className="text-[10px] bg-blue-50 text-blue-600 px-1.5 py-0.5 rounded">{a.entities.length} entities</span>
+                        <span className="inline-flex items-center gap-1 text-[10px] bg-blue-50 text-blue-600 px-1.5 py-0.5 rounded border border-blue-100">
+                          <Tag className="w-2.5 h-2.5" />{a.entities.length}
+                        </span>
                       )}
                       {a.contradictions && a.contradictions.length > 0 && (
-                        <span className="text-[10px] bg-amber-50 text-amber-600 px-1.5 py-0.5 rounded">{a.contradictions.length} issues</span>
+                        <span className="inline-flex items-center gap-1 text-[10px] bg-amber-50 text-amber-600 px-1.5 py-0.5 rounded border border-amber-100">
+                          <AlertTriangle className="w-2.5 h-2.5" />{a.contradictions.length}
+                        </span>
+                      )}
+                      {a.obligations && a.obligations.length > 0 && (
+                        <span className="inline-flex items-center gap-1 text-[10px] bg-emerald-50 text-emerald-600 px-1.5 py-0.5 rounded border border-emerald-100">
+                          <ClipboardList className="w-2.5 h-2.5" />{a.obligations.length}
+                        </span>
+                      )}
+                      {a.model && a.model !== "regex" && (
+                        <span className="inline-flex items-center gap-1 text-[10px] bg-indigo-50 text-indigo-600 px-1.5 py-0.5 rounded border border-indigo-100">
+                          <Cpu className="w-2.5 h-2.5" />ML
+                        </span>
                       )}
                     </div>
                   </div>
-                  <div className="flex items-center gap-3">
-                    <span className={`text-sm font-bold px-3 py-1 rounded-full ${
-                      a.grade === "F" ? "bg-red-100 text-red-700" :
-                      a.grade === "D" ? "bg-orange-100 text-orange-700" :
-                      a.grade === "C" ? "bg-yellow-100 text-yellow-700" :
-                      "bg-green-100 text-green-700"
-                    }`}>
-                      {a.grade} · {a.risk_score}
-                    </span>
-                  </div>
+                  <span className={`self-start sm:self-auto text-sm font-bold px-3 py-1 rounded-full whitespace-nowrap ${
+                    a.grade === "F" ? "bg-red-100 text-red-700" :
+                    a.grade === "D" ? "bg-orange-100 text-orange-700" :
+                    a.grade === "C" ? "bg-yellow-100 text-yellow-700" :
+                    "bg-green-100 text-green-700"
+                  }`}>
+                    {a.grade} · {a.risk_score}
+                  </span>
                 </div>
               ))}
             </div>
           ) : (
-            <div className="px-6 py-12 text-center text-gray-400">
-              <p className="text-4xl mb-3">📋</p>
-              <p>No scans yet. <Link href="/dashboard-pages/analyze" className="text-indigo-600 hover:underline">Start your first scan</Link></p>
+            <div className="px-6 py-12 text-center">
+              <Layers className="w-10 h-10 text-zinc-200 mx-auto mb-3" />
+              <p className="text-sm text-gray-400">No scans yet. <Link href="/dashboard-pages/analyze" className="text-indigo-600 hover:underline">Start your first scan</Link></p>
             </div>
           )}
         </div>
 
-        {/* Upgrade CTA for free users */}
+        {/* Upgrade CTA */}
         {plan === "free" && (
-          <div className="mt-8 bg-indigo-50 border border-indigo-200 rounded-xl p-6 flex items-center justify-between">
+          <div className="mt-8 bg-indigo-50 border border-indigo-200 rounded-xl p-5 sm:p-6 flex flex-col sm:flex-row items-start sm:items-center justify-between gap-4">
             <div>
               <p className="font-semibold text-indigo-900">Upgrade to Pro</p>
-              <p className="text-sm text-indigo-700 mt-1">Unlimited scans, contract comparison, PDF exports, and team features.</p>
+              <p className="text-sm text-indigo-700 mt-1">Unlimited scans, contract comparison, PDF exports, obligation tracking, and team features.</p>
             </div>
-            <Link
-              href="/#pricing"
-              className="bg-indigo-600 text-white px-6 py-2.5 rounded-lg font-semibold text-sm hover:bg-indigo-700 transition"
-            >
+            <Link href="/#pricing" className="bg-indigo-600 text-white px-6 py-2.5 rounded-lg font-semibold text-sm hover:bg-indigo-700 transition whitespace-nowrap">
               View Plans
             </Link>
           </div>

web/app/page.tsx

@@ -1,10 +1,9 @@
 import Link from "next/link";
 import {
-  ShieldCheck, ShieldAlert, Scale, Gavel, ScrollText, Handshake,
-  ScanText, FileCheck, TriangleAlert, ArrowRight, Zap, Eye, Download,
-  ChevronRight, Sparkles, Lock, Globe, Ban, FileX, Stamp, Layers,
-  Tag, AlertTriangle, ClipboardList, Landmark, Building, DollarSign,
-  MapPin, Hash, BookOpen, CheckCircle
+  ShieldCheck, ShieldAlert, Scale, Gavel, ScanText, FileCheck,
+  TriangleAlert, ArrowRight, Zap, Eye, Download, ChevronRight,
+  Sparkles, Lock, Globe, Ban, FileX, Stamp, Layers, Tag, AlertTriangle,
+  ClipboardList, Landmark, Building, BookOpen, CheckCircle, Cpu
 } from "lucide-react";
 
 const CLAUSES = [
@@ -17,30 +16,30 @@ const CLAUSES = [
   { icon: Gavel, name: "Choice of law", desc: "Foreign law overrides your local protections", severity: "medium" },
   { icon: Lock, name: "IP Ownership", desc: "Intellectual property transferred entirely", severity: "critical" },
   { icon: Layers, name: "41 CUAD Categories", desc: "Full taxonomy: NDA, MSA, SLA, and more", severity: "low" },
-  { icon: Tag, name: "Legal NER", desc: "Extract parties, dates, money, jurisdictions", severity: "low" },
-  { icon: AlertTriangle, name: "Contradictions", desc: "Detect conflicting clauses automatically", severity: "high" },
-  { icon: ClipboardList, name: "Obligations", desc: "Track monetary, compliance, reporting tasks", severity: "medium" },
-  { icon: Landmark, name: "Compliance", desc: "GDPR, CCPA, SOX, HIPAA, FINRA checks", severity: "high" },
-  { icon: BookOpen, name: "Compare Contracts", desc: "Side-by-side diff with alignment scoring", severity: "low" },
+  { icon: Tag, name: "ML Legal NER", desc: "Extract parties, dates, money, jurisdictions via Legal-BERT", severity: "low" },
+  { icon: AlertTriangle, name: "NLI Contradictions", desc: "Detect conflicting clauses with DeBERTa-v3 NLI model", severity: "high" },
+  { icon: ClipboardList, name: "Obligations", desc: "Track monetary, compliance, reporting tasks with priority", severity: "medium" },
+  { icon: Landmark, name: "Compliance", desc: "GDPR, CCPA, SOX, HIPAA, FINRA with negation detection", severity: "high" },
+  { icon: BookOpen, name: "Compare Contracts", desc: "Semantic similarity with sentence embeddings", severity: "low" },
 ];
 
 const STEPS = [
   { icon: Download, title: "Upload or paste", desc: "Drop a PDF, DOCX, or paste contract text directly." },
-  { icon: ScanText, title: "AI scans 41 categories", desc: "Legal-BERT + CUAD detects clauses, risks, entities." },
-  { icon: TriangleAlert, title: "Get actionable insights", desc: "Risk score, contradictions, obligations, compliance gaps." },
+  { icon: ScanText, title: "3 AI models analyze", desc: "Legal-BERT classifier + Legal NER + DeBERTa NLI scan your contract." },
+  { icon: TriangleAlert, title: "Get precise insights", desc: "Risk score, contradictions, obligations, compliance gaps with source indicators." },
 ];
 
 const PRICING = [
   {
-    name: "Free", price: "₹0", period: "", highlight: false, cta: "Get started",
-    features: ["10 scans per month", "41 clause categories", "Risk scoring", "Legal NER", "Contradiction detection", "Compliance checks"],
+    name: "Free", price: "0", period: "", highlight: false, cta: "Get started",
+    features: ["10 scans per month", "41 clause categories", "Risk scoring", "ML Legal NER", "NLI contradiction detection", "Compliance with negation detection"],
   },
   {
-    name: "Pro", price: "₹999", period: "/mo", highlight: true, cta: "Start free trial",
-    features: ["Unlimited scans", "Upload PDF/DOCX files", "Contract comparison", "AI clause explanations", "Scan history", "PDF report export", "Obligation tracker", "Priority support"],
+    name: "Pro", price: "999", period: "/mo", highlight: true, cta: "Start free trial",
+    features: ["Unlimited scans", "Upload PDF/DOCX files", "Contract comparison", "AI clause explanations", "Scan history", "PDF report export", "Obligation tracker with priority", "Priority support"],
   },
   {
-    name: "Team", price: "₹3,999", period: "/mo", highlight: false, cta: "Talk to us",
+    name: "Team", price: "3,999", period: "/mo", highlight: false, cta: "Talk to us",
     features: ["Everything in Pro", "5 team seats", "10,000 API calls", "Shared dashboard", "Slack support", "Custom clause rules", "Enterprise compliance"],
   },
 ];
@@ -56,53 +55,50 @@ export default function Home() {
   return (
     <main className="min-h-screen bg-white text-zinc-900">
       {/* Hero */}
-      <section className="max-w-6xl mx-auto px-5 pt-24 pb-20">
+      <section className="max-w-6xl mx-auto px-4 sm:px-6 pt-16 sm:pt-24 pb-16 sm:pb-20">
         <div className="max-w-2xl">
           <div className="inline-flex items-center gap-2 px-3 py-1 rounded-full border border-zinc-200 text-[13px] text-zinc-500 mb-6">
             <Sparkles className="w-3.5 h-3.5 text-zinc-400" />
-            Trained on 13,000+ legal clauses across 41 categories
+            3 ML models · 41 clause categories · negation-aware compliance
           </div>
-          <h1 className="text-[42px] sm:text-5xl font-semibold tracking-tight leading-[1.1]">
-            Know what you are<br />agreeing to
+          <h1 className="text-3xl sm:text-[42px] lg:text-5xl font-semibold tracking-tight leading-[1.1]">
+            Know what you are<br className="hidden sm:block" /> agreeing to
           </h1>
-          <p className="mt-5 text-[17px] text-zinc-500 leading-relaxed max-w-lg">
-            ClauseGuard scans contracts, terms of service, and leases using AI trained on legal data.
-            Get clause detection, risk scoring, entity extraction, contradiction alerts, and compliance checks.
+          <p className="mt-5 text-base sm:text-[17px] text-zinc-500 leading-relaxed max-w-lg">
+            ClauseGuard scans contracts, terms of service, and leases using 3 specialized AI models.
+            Get precise clause detection, risk scoring, ML entity extraction, NLI contradiction alerts, and negation-aware compliance checks.
           </p>
-          <div className="mt-8 flex flex-wrap gap-3">
-            <Link href="/dashboard-pages/analyze" className="inline-flex items-center gap-2 bg-zinc-900 text-white px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
-              <ScanText className="w-4 h-4" />
-              Try the scanner
+          <div className="mt-8 flex flex-col sm:flex-row gap-3">
+            <Link href="/dashboard-pages/analyze" className="inline-flex items-center justify-center gap-2 bg-zinc-900 text-white px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
+              <ScanText className="w-4 h-4" />Try the scanner
             </Link>
-            <Link href="/dashboard-pages/compare" className="inline-flex items-center gap-2 border border-zinc-200 px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
-              Compare contracts
-              <ArrowRight className="w-4 h-4" />
+            <Link href="/dashboard-pages/compare" className="inline-flex items-center justify-center gap-2 border border-zinc-200 px-5 py-2.5 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
+              Compare contracts<ArrowRight className="w-4 h-4" />
             </Link>
           </div>
-          <p className="mt-4 text-xs text-zinc-400">No account needed for free tier · 10 scans/month</p>
+          <p className="mt-4 text-xs text-zinc-400">No account needed for free tier. 10 scans/month.</p>
         </div>
       </section>
 
-      {/* What it detects */}
+      {/* Features */}
       <section id="features" className="border-t border-zinc-100">
-        <div className="max-w-6xl mx-auto px-5 py-20">
+        <div className="max-w-6xl mx-auto px-4 sm:px-6 py-16 sm:py-20">
           <div className="flex items-center gap-2 mb-2">
             <ShieldCheck className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">Detection</p>
           </div>
-          <h2 className="text-2xl font-semibold tracking-tight">14 powerful analysis features</h2>
-          <p className="mt-2 text-zinc-500 text-[15px] max-w-lg">
-            Based on the CUAD taxonomy + CLAUDETTE framework — the same datasets used by EU consumer protection researchers and Stanford NLP.
+          <h2 className="text-xl sm:text-2xl font-semibold tracking-tight">14 powerful analysis features</h2>
+          <p className="mt-2 text-zinc-500 text-sm sm:text-[15px] max-w-lg">
+            Based on the CUAD taxonomy + CLAUDETTE framework, the same datasets used by EU consumer protection researchers and Stanford NLP.
           </p>
-
-          <div className="mt-10 grid sm:grid-cols-2 lg:grid-cols-4 gap-3">
+          <div className="mt-8 sm:mt-10 grid grid-cols-2 sm:grid-cols-2 lg:grid-cols-4 gap-2 sm:gap-3">
             {CLAUSES.map((c) => (
-              <div key={c.name} className="group border border-zinc-100 rounded-xl p-4 hover:border-zinc-200 hover:shadow-sm transition-all cursor-default">
-                <div className={`w-8 h-8 rounded-lg flex items-center justify-center border ${sevColor[c.severity]}`}>
-                  <c.icon className="w-4 h-4" />
+              <div key={c.name} className="group border border-zinc-100 rounded-xl p-3 sm:p-4 hover:border-zinc-200 hover:shadow-sm transition-all cursor-default">
+                <div className={`w-7 h-7 sm:w-8 sm:h-8 rounded-lg flex items-center justify-center border ${sevColor[c.severity]}`}>
+                  <c.icon className="w-3.5 h-3.5 sm:w-4 sm:h-4" />
                 </div>
-                <p className="mt-3 text-sm font-medium">{c.name}</p>
-                <p className="mt-1 text-[13px] text-zinc-500 leading-relaxed">{c.desc}</p>
+                <p className="mt-2.5 sm:mt-3 text-xs sm:text-sm font-medium">{c.name}</p>
+                <p className="mt-0.5 sm:mt-1 text-[11px] sm:text-[13px] text-zinc-500 leading-relaxed">{c.desc}</p>
               </div>
             ))}
           </div>
@@ -111,14 +107,13 @@ export default function Home() {
 
       {/* How it works */}
       <section className="border-t border-zinc-100 bg-zinc-50/50">
-        <div className="max-w-6xl mx-auto px-5 py-20">
+        <div className="max-w-6xl mx-auto px-4 sm:px-6 py-16 sm:py-20">
           <div className="flex items-center gap-2 mb-2">
             <Zap className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">How it works</p>
           </div>
-          <h2 className="text-2xl font-semibold tracking-tight">Three steps, under 30 seconds</h2>
-
-          <div className="mt-10 grid sm:grid-cols-3 gap-8">
+          <h2 className="text-xl sm:text-2xl font-semibold tracking-tight">Three steps, under 30 seconds</h2>
+          <div className="mt-8 sm:mt-10 grid sm:grid-cols-3 gap-6 sm:gap-8">
             {STEPS.map((s, i) => (
               <div key={s.title} className="relative">
                 <div className="w-10 h-10 rounded-xl bg-white border border-zinc-200 flex items-center justify-center shadow-sm">
@@ -126,36 +121,37 @@ export default function Home() {
                 </div>
                 <h3 className="mt-4 text-[15px] font-medium">{s.title}</h3>
                 <p className="mt-1.5 text-[13px] text-zinc-500 leading-relaxed">{s.desc}</p>
-                {i < 2 && (
-                  <ChevronRight className="hidden sm:block absolute top-4 -right-5 w-4 h-4 text-zinc-300" />
-                )}
+                {i < 2 && <ChevronRight className="hidden sm:block absolute top-4 -right-5 w-4 h-4 text-zinc-300" />}
               </div>
             ))}
           </div>
         </div>
       </section>
 
-      {/* Models */}
+      {/* Technology */}
       <section className="border-t border-zinc-100">
-        <div className="max-w-6xl mx-auto px-5 py-20">
+        <div className="max-w-6xl mx-auto px-4 sm:px-6 py-16 sm:py-20">
           <div className="flex items-center gap-2 mb-2">
-            <CheckCircle className="w-4 h-4 text-zinc-400" />
+            <Cpu className="w-4 h-4 text-zinc-400" />
             <p className="text-[13px] font-medium text-zinc-400 uppercase tracking-wider">Technology</p>
           </div>
-          <h2 className="text-2xl font-semibold tracking-tight">Built on production-grade models</h2>
-          <div className="mt-8 grid sm:grid-cols-2 lg:grid-cols-3 gap-4">
+          <h2 className="text-xl sm:text-2xl font-semibold tracking-tight">Built on 3 production ML models</h2>
+          <div className="mt-8 grid sm:grid-cols-2 lg:grid-cols-3 gap-3 sm:gap-4">
             {[
-              { name: "Legal-BERT + CUAD", desc: "41 clause categories fine-tuned on 510 contracts, 13K annotations", source: "Mokshith31/legalbert-contract-clause-classification" },
-              { name: "Legal NER Engine", desc: "Regex + pattern-based extraction for parties, dates, money, jurisdictions, defined terms", source: "Custom" },
-              { name: "NLI Detection", desc: "Heuristic contradiction detection: liability caps, governing law conflicts, IP ownership", source: "Custom" },
-              { name: "Compliance Engine", desc: "GDPR, CCPA, SOX, HIPAA, FINRA keyword matching with severity scoring", source: "Custom" },
-              { name: "Obligation Tracker", desc: "Extracts monetary, compliance, reporting, delivery, and termination obligations", source: "Custom" },
-              { name: "Comparison Engine", desc: "SequenceMatcher-based clause alignment with risk delta analysis", source: "Custom" },
+              { name: "Legal-BERT Classifier", icon: Cpu, desc: "LoRA fine-tuned on 41 CUAD categories with sigmoid multi-label classification and per-class thresholds", source: "Mokshith31/legalbert-contract-clause-classification" },
+              { name: "Legal-BERT NER", icon: Tag, desc: "ML-based named entity recognition for parties, dates, money, jurisdictions with regex augmentation", source: "matterstack/legal-bert-ner" },
+              { name: "DeBERTa-v3 NLI", icon: AlertTriangle, desc: "Cross-encoder model for semantic contradiction detection between clause pairs", source: "cross-encoder/nli-deberta-v3-base" },
+              { name: "Compliance Engine", icon: ShieldCheck, desc: "GDPR, CCPA, SOX, HIPAA, FINRA checking with negation detection and context snippets", source: "Negation-aware keyword + semantic" },
+              { name: "Obligation Tracker", icon: ClipboardList, desc: "Extracts monetary, compliance, reporting, delivery obligations with priority scoring", source: "Context-filtered regex" },
+              { name: "Comparison Engine", icon: Layers, desc: "Semantic similarity via sentence-transformers with SequenceMatcher fallback", source: "all-MiniLM-L6-v2" },
             ].map((m) => (
-              <div key={m.name} className="border border-zinc-100 rounded-xl p-4 hover:border-zinc-200 transition-all">
-                <p className="text-sm font-medium text-zinc-900">{m.name}</p>
-                <p className="text-[13px] text-zinc-500 mt-1 leading-relaxed">{m.desc}</p>
-                <p className="text-[11px] text-zinc-400 mt-2">{m.source}</p>
+              <div key={m.name} className="border border-zinc-100 rounded-xl p-4 hover:border-zinc-200 hover:shadow-sm transition-all">
+                <div className="flex items-center gap-2 mb-2">
+                  <m.icon className="w-4 h-4 text-zinc-400" />
+                  <p className="text-sm font-medium text-zinc-900">{m.name}</p>
+                </div>
+                <p className="text-[13px] text-zinc-500 leading-relaxed">{m.desc}</p>
+                <p className="text-[11px] text-zinc-400 mt-2 font-mono">{m.source}</p>
               </div>
             ))}
           </div>
@@ -164,33 +160,27 @@ export default function Home() {
 
       {/* Pricing */}
       <section id="pricing" className="border-t border-zinc-100">
-        <div className="max-w-6xl mx-auto px-5 py-20">
-          <h2 className="text-2xl font-semibold tracking-tight">Pricing</h2>
-          <p className="mt-2 text-zinc-500 text-[15px]">Free forever. Upgrade when you need more.</p>
-
-          <div className="mt-10 grid sm:grid-cols-3 gap-5 max-w-4xl">
+        <div className="max-w-6xl mx-auto px-4 sm:px-6 py-16 sm:py-20">
+          <h2 className="text-xl sm:text-2xl font-semibold tracking-tight">Pricing</h2>
+          <p className="mt-2 text-zinc-500 text-sm sm:text-[15px]">Free forever. Upgrade when you need more.</p>
+          <div className="mt-8 sm:mt-10 grid sm:grid-cols-3 gap-4 sm:gap-5 max-w-4xl">
             {PRICING.map((plan) => (
-              <div key={plan.name}
-                className={`rounded-xl p-6 transition-shadow ${
-                  plan.highlight ? "border-2 border-zinc-900 shadow-sm" : "border border-zinc-200"
-                }`}>
+              <div key={plan.name} className={`rounded-xl p-5 sm:p-6 transition-shadow ${plan.highlight ? "border-2 border-zinc-900 shadow-sm" : "border border-zinc-200"}`}>
                 <p className="text-[13px] font-medium text-zinc-400">{plan.name}</p>
                 <p className="mt-2 flex items-baseline gap-1">
-                  <span className="text-3xl font-semibold tracking-tight">{plan.price}</span>
+                  <span className="text-[11px] text-zinc-400">INR</span>
+                  <span className="text-2xl sm:text-3xl font-semibold tracking-tight">{plan.price}</span>
                   <span className="text-sm text-zinc-400">{plan.period}</span>
                 </p>
                 <ul className="mt-5 space-y-2.5">
                   {plan.features.map((f) => (
                     <li key={f} className="flex items-start gap-2.5 text-[13px] text-zinc-600">
-                      <FileCheck className="w-3.5 h-3.5 text-zinc-300 mt-0.5 shrink-0" />
-                      {f}
+                      <FileCheck className="w-3.5 h-3.5 text-zinc-300 mt-0.5 shrink-0" />{f}
                     </li>
                   ))}
                 </ul>
                 <Link href={plan.name === "Free" ? "/auth/signup" : plan.name === "Team" ? "mailto:hello@clauseguardweb.netlify.app" : "/auth/signup"}
-                  className={`mt-6 block w-full py-2.5 rounded-lg text-[13px] font-medium text-center transition-colors ${
-                  plan.highlight ? "bg-zinc-900 text-white hover:bg-zinc-800" : "border border-zinc-200 text-zinc-700 hover:bg-zinc-50"
-                }`}>
+                  className={`mt-6 block w-full py-2.5 rounded-lg text-[13px] font-medium text-center transition-colors ${plan.highlight ? "bg-zinc-900 text-white hover:bg-zinc-800" : "border border-zinc-200 text-zinc-700 hover:bg-zinc-50"}`}>
                   {plan.cta}
                 </Link>
               </div>
@@ -201,20 +191,16 @@ export default function Home() {
 
       {/* CTA */}
       <section className="border-t border-zinc-100 bg-zinc-50/50">
-        <div className="max-w-6xl mx-auto px-5 py-16 text-center">
+        <div className="max-w-6xl mx-auto px-4 sm:px-6 py-12 sm:py-16 text-center">
           <Lock className="w-6 h-6 text-zinc-300 mx-auto mb-4" />
-          <h2 className="text-2xl font-semibold tracking-tight">Read the fine print without reading it</h2>
-          <p className="mt-2 text-[15px] text-zinc-500 max-w-md mx-auto">
-            Join thousands protecting themselves before clicking accept.
-          </p>
-          <div className="mt-6 flex gap-3 justify-center">
-            <Link href="/auth/signup" className="inline-flex items-center gap-2 bg-zinc-900 text-white px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
-              <ScanText className="w-4 h-4" />
-              Get started free
+          <h2 className="text-xl sm:text-2xl font-semibold tracking-tight">Read the fine print without reading it</h2>
+          <p className="mt-2 text-sm sm:text-[15px] text-zinc-500 max-w-md mx-auto">Join thousands protecting themselves before clicking accept.</p>
+          <div className="mt-6 flex flex-col sm:flex-row gap-3 justify-center">
+            <Link href="/auth/signup" className="inline-flex items-center justify-center gap-2 bg-zinc-900 text-white px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-800 transition-colors">
+              <ScanText className="w-4 h-4" />Get started free
             </Link>
-            <Link href="/dashboard-pages/compare" className="inline-flex items-center gap-2 border border-zinc-200 px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
-              <ArrowRight className="w-4 h-4" />
-              Compare contracts
+            <Link href="/dashboard-pages/compare" className="inline-flex items-center justify-center gap-2 border border-zinc-200 px-6 py-3 rounded-lg text-sm font-medium hover:bg-zinc-50 transition-colors">
+              <ArrowRight className="w-4 h-4" />Compare contracts
             </Link>
           </div>
         </div>
@@ -222,10 +208,10 @@ export default function Home() {
 
       {/* Footer */}
       <footer className="border-t border-zinc-100">
-        <div className="max-w-6xl mx-auto px-5 py-8 flex flex-col sm:flex-row justify-between items-center gap-4">
+        <div className="max-w-6xl mx-auto px-4 sm:px-6 py-8 flex flex-col sm:flex-row justify-between items-center gap-4">
           <div className="flex items-center gap-2">
             <ShieldCheck className="w-4 h-4 text-zinc-300" />
-            <span className="text-[13px] text-zinc-400">ClauseGuard — not legal advice</span>
+            <span className="text-[13px] text-zinc-400">ClauseGuard v3.0 — not legal advice</span>
           </div>
           <div className="flex gap-5 text-[13px] text-zinc-400">
             <Link href="/privacy" className="hover:text-zinc-600">Privacy</Link>

web/components/nav.tsx

@@ -31,11 +31,11 @@ export function Nav() {
 
   return (
     <nav className="sticky top-0 z-50 bg-white/80 backdrop-blur-md border-b border-zinc-100">
-      <div className="max-w-6xl mx-auto px-5 h-14 flex items-center justify-between">
+      <div className="max-w-6xl mx-auto px-4 sm:px-5 h-14 flex items-center justify-between">
         <Link href="/" className="flex items-center gap-2">
           <ShieldCheck className="w-5 h-5 text-zinc-900" strokeWidth={2.2} />
           <span className="font-semibold text-[15px] tracking-tight text-zinc-900">ClauseGuard</span>
-          <span className="hidden sm:inline text-[10px] font-medium text-zinc-400 ml-1 border border-zinc-200 px-1.5 py-0.5 rounded">v2.0</span>
+          <span className="hidden sm:inline text-[10px] font-medium text-zinc-400 ml-1 border border-zinc-200 px-1.5 py-0.5 rounded">v3.0</span>
         </Link>
 
         <div className="hidden md:flex items-center gap-1">