Upload 2 files

main.py

@@ -0,0 +1,1681 @@
+"""
+Eatlytic v3 — Production-ready backend
+Fixes applied (from Founder's Playbook audit):
+  SECURITY: CORS locked down, ADMIN_TOKEN guard, rate-limit tightened
+  BUG: JSON storage → SQLite (WAL mode, thread-safe)
+  BUG: bare except: → named exceptions everywhere
+  BUG: duckduckgo hard import → guarded try/except
+  BUG: easyocr module-level init → lazy double-checked locking (no 30s startup freeze)
+  BUG: tuple[bytes,str] annotation → Python <3.9 compatible
+  BUG: anchor="mm" on bitmap font → draw_centered() with getbbox()
+  BUG: HexColor("#...") → HexColor without # prefix
+  BUG: ROWBACKGROUNDS / PADDING invalid reportlab commands → correct commands
+  BUG: chart_data rounding off-by-one → largest-bucket clamp
+  BUG: nutrient value "34g" → NaN → regex sanitise to float
+  BUG: score always 6 → removed "score":7 anchor, added strict rubric, v3 cache key
+  BUG: front image passes through → NUTRITION_TABLE_ANCHORS require 2+ back-label terms
+  FEATURE: Medical disclaimer on every response (legal / FSSAI compliance)
+  FEATURE: Allergen profile + live scan alerts
+  FEATURE: Streak tracking per device
+  FEATURE: Auto-log every scan into daily_logs table
+  FEATURE: /daily-summary, /daily-log, /food-search, /allergen-profile, /nps
+  FEATURE: /onboarding-complete, /admin/analytics
+  FEATURE: LLM abstraction layer (call_llm) — swap provider in one line
+  FEATURE: asyncio.to_thread for LLM calls — never blocks ASGI loop
+"""
+
+import os
+import re
+import json
+import sqlite3
+import asyncio
+import logging
+import hashlib
+import base64
+import secrets
+import tempfile
+import threading
+import datetime
+import cv2
+import numpy as np
+from contextlib import contextmanager
+from PIL import Image, ImageDraw, ImageFont, ImageFilter, ImageEnhance
+from io import BytesIO
+from fastapi import FastAPI, File, UploadFile, Form, Request, HTTPException, Security
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse, JSONResponse, Response
+from fastapi.security import APIKeyHeader
+
+# ── DuckDuckGo: guarded import ─────────────────────────────────────────
+# Hard import crashes the server if wrong package version is installed.
+try:
+    from duckduckgo_search import DDGS as _DDGS
+    _DDGS_OK = True
+except Exception:
+    _DDGS = None          # type: ignore
+    _DDGS_OK = False
+
+from groq import Groq
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ══════════════════════════════════════════════════════════════════════
+#  CONFIG
+# ══════════════════════════════════════════════════════════════════════
+limiter      = Limiter(key_func=get_remote_address)
+app          = FastAPI(title="Eatlytic v3 — Food Intelligence")
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+# SECURITY FIX: lock CORS to production domain (allow_origins=["*"] is wide open).
+# Set ALLOWED_ORIGIN env var in production. Falls back to * only in dev.
+_ALLOWED_ORIGIN = os.environ.get("ALLOWED_ORIGIN", "*")
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins     = [_ALLOWED_ORIGIN],
+    allow_methods     = ["GET", "POST", "DELETE"],
+    allow_headers     = ["*"],
+    allow_credentials = _ALLOWED_ORIGIN != "*",
+)
+
+DATA_DIR  = os.path.join(os.getcwd(), "data")
+CACHE_DIR = os.environ.get("HF_HOME", "/app/.cache")
+MODEL_DIR = os.path.join(CACHE_DIR, "easyocr_models")
+for _d in [MODEL_DIR, DATA_DIR]:
+    os.makedirs(_d, exist_ok=True)
+
+FREE_SCAN_LIMIT  = 10
+APP_VERSION      = "3.0"
+MEDICAL_DISCLAIMER = (
+    "⚕️ For informational purposes only — not medical advice. "
+    "Consult a qualified nutritionist or physician before making dietary decisions."
+)
+
+# ══════════════════════════════════════════════════════════════════════
+#  SQLite DATABASE  (replaces ALL JSON file storage — Playbook P0)
+# ══════════════════════════════════════════════════════════════════════
+DB_FILE  = os.path.join(DATA_DIR, "eatlytic.db")
+_db_lock = threading.Lock()
+
+
+def get_db() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_FILE, check_same_thread=False, timeout=10)
+    conn.row_factory = sqlite3.Row
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+    return conn
+
+
+@contextmanager
+def db_conn():
+    """Thread-safe DB context manager with auto-commit/rollback."""
+    conn = get_db()
+    try:
+        yield conn
+        conn.commit()
+    except Exception:
+        conn.rollback()
+        raise
+    finally:
+        conn.close()
+
+
+def init_db():
+    with db_conn() as conn:
+        conn.executescript("""
+            CREATE TABLE IF NOT EXISTS devices (
+                device_key      TEXT PRIMARY KEY,
+                created_at      TEXT DEFAULT (datetime('now')),
+                is_pro          INTEGER DEFAULT 0,
+                month           TEXT DEFAULT '',
+                scan_count      INTEGER DEFAULT 0,
+                streak_days     INTEGER DEFAULT 0,
+                last_scan_date  TEXT DEFAULT '',
+                persona         TEXT DEFAULT 'General Adult',
+                language        TEXT DEFAULT 'en',
+                tdee            REAL DEFAULT 0,
+                onboarding_done INTEGER DEFAULT 0
+            );
+
+            CREATE TABLE IF NOT EXISTS scans (
+                id            INTEGER PRIMARY KEY AUTOINCREMENT,
+                device_key    TEXT NOT NULL,
+                product_name  TEXT DEFAULT 'Unknown',
+                score         INTEGER DEFAULT 0,
+                verdict       TEXT DEFAULT '',
+                calories      REAL DEFAULT 0,
+                protein       REAL DEFAULT 0,
+                carbs         REAL DEFAULT 0,
+                fat           REAL DEFAULT 0,
+                sodium        REAL DEFAULT 0,
+                fiber         REAL DEFAULT 0,
+                sugar         REAL DEFAULT 0,
+                persona       TEXT DEFAULT '',
+                language      TEXT DEFAULT 'en',
+                scanned_at    TEXT DEFAULT (datetime('now')),
+                analysis_json TEXT DEFAULT '{}'
+            );
+
+            CREATE TABLE IF NOT EXISTS daily_logs (
+                id          INTEGER PRIMARY KEY AUTOINCREMENT,
+                device_key  TEXT NOT NULL,
+                log_date    TEXT NOT NULL,
+                meal_name   TEXT DEFAULT '',
+                calories    REAL DEFAULT 0,
+                protein     REAL DEFAULT 0,
+                carbs       REAL DEFAULT 0,
+                fat         REAL DEFAULT 0,
+                sodium      REAL DEFAULT 0,
+                fiber       REAL DEFAULT 0,
+                sugar       REAL DEFAULT 0,
+                source      TEXT DEFAULT 'scan',
+                logged_at   TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS allergen_profiles (
+                device_key TEXT PRIMARY KEY,
+                allergens  TEXT DEFAULT '[]',
+                conditions TEXT DEFAULT '[]',
+                updated_at TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS nps_responses (
+                id           INTEGER PRIMARY KEY AUTOINCREMENT,
+                device_key   TEXT NOT NULL,
+                score        INTEGER NOT NULL,
+                comment      TEXT DEFAULT '',
+                submitted_at TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS api_keys (
+                api_key          TEXT PRIMARY KEY,
+                client_name      TEXT NOT NULL,
+                plan             TEXT DEFAULT 'business',
+                scans_this_month INTEGER DEFAULT 0,
+                month            TEXT DEFAULT '',
+                active           INTEGER DEFAULT 1,
+                created_at       TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS ocr_cache (
+                cache_key   TEXT PRIMARY KEY,
+                result_json TEXT NOT NULL,
+                created_at  TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE TABLE IF NOT EXISTS ai_cache (
+                cache_key   TEXT PRIMARY KEY,
+                result_json TEXT NOT NULL,
+                created_at  TEXT DEFAULT (datetime('now'))
+            );
+
+            CREATE INDEX IF NOT EXISTS idx_scans_device      ON scans(device_key);
+            CREATE INDEX IF NOT EXISTS idx_scans_date        ON scans(scanned_at);
+            CREATE INDEX IF NOT EXISTS idx_daily_device_date ON daily_logs(device_key, log_date);
+        """)
+    logger.info("DB ready at %s", DB_FILE)
+
+
+init_db()
+
+
+# ── Cache helpers ──────────────────────────────────────────────────────
+def get_ocr_cache(key: str):
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT result_json FROM ocr_cache WHERE cache_key=?", (key,)
+            ).fetchone()
+        return json.loads(row["result_json"]) if row else None
+    except Exception:
+        return None
+
+
+def set_ocr_cache(key: str, value: dict):
+    try:
+        with db_conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO ocr_cache(cache_key,result_json) VALUES(?,?)",
+                (key, json.dumps(value))
+            )
+    except Exception as exc:
+        logger.warning("set_ocr_cache failed: %s", exc)
+
+
+def get_ai_cache(key: str):
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT result_json FROM ai_cache WHERE cache_key=?", (key,)
+            ).fetchone()
+        return json.loads(row["result_json"]) if row else None
+    except Exception:
+        return None
+
+
+def set_ai_cache(key: str, value: dict):
+    try:
+        with db_conn() as conn:
+            conn.execute(
+                "INSERT OR REPLACE INTO ai_cache(cache_key,result_json) VALUES(?,?)",
+                (key, json.dumps(value))
+            )
+    except Exception as exc:
+        logger.warning("set_ai_cache failed: %s", exc)
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  SCAN QUOTA (SQLite-backed — survives restarts)
+# ══════════════════════════════════════════════════════════════════════
+def _ensure_device(device_key: str):
+    try:
+        with db_conn() as conn:
+            conn.execute(
+                "INSERT OR IGNORE INTO devices(device_key) VALUES(?)", (device_key,)
+            )
+    except Exception as exc:
+        logger.warning("_ensure_device: %s", exc)
+
+
+def check_and_increment_scan(device_key: str) -> dict:
+    _ensure_device(device_key)
+    month_key = datetime.date.today().isoformat()[:7]
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT is_pro, month, scan_count FROM devices WHERE device_key=?",
+                (device_key,)
+            ).fetchone()
+            if not row:
+                return {"allowed": False, "scans_used": 0, "scans_remaining": 0, "is_pro": False}
+
+            if row["month"] != month_key:
+                conn.execute(
+                    "UPDATE devices SET month=?, scan_count=0 WHERE device_key=?",
+                    (month_key, device_key)
+                )
+                count = 0
+            else:
+                count = row["scan_count"]
+
+            if row["is_pro"]:
+                conn.execute(
+                    "UPDATE devices SET scan_count=scan_count+1 WHERE device_key=?",
+                    (device_key,)
+                )
+                return {"allowed": True, "scans_used": count + 1,
+                        "scans_remaining": 9999, "is_pro": True}
+
+            if count >= FREE_SCAN_LIMIT:
+                return {"allowed": False, "scans_used": count,
+                        "scans_remaining": 0, "is_pro": False}
+
+            conn.execute(
+                "UPDATE devices SET scan_count=scan_count+1 WHERE device_key=?",
+                (device_key,)
+            )
+            new_count = count + 1
+            return {"allowed": True, "scans_used": new_count,
+                    "scans_remaining": FREE_SCAN_LIMIT - new_count, "is_pro": False}
+    except Exception as exc:
+        logger.error("check_and_increment_scan: %s", exc)
+        return {"allowed": True, "scans_used": 0, "scans_remaining": FREE_SCAN_LIMIT, "is_pro": False}
+
+
+def update_streak(device_key: str):
+    """Increment streak; reset if user missed a day."""
+    _ensure_device(device_key)
+    today     = datetime.date.today().isoformat()
+    yesterday = (datetime.date.today() - datetime.timedelta(days=1)).isoformat()
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT streak_days, last_scan_date FROM devices WHERE device_key=?",
+                (device_key,)
+            ).fetchone()
+            if not row or row["last_scan_date"] == today:
+                return
+            streak = (row["streak_days"] + 1) if row["last_scan_date"] == yesterday else 1
+            conn.execute(
+                "UPDATE devices SET streak_days=?, last_scan_date=? WHERE device_key=?",
+                (streak, today, device_key)
+            )
+    except Exception as exc:
+        logger.warning("update_streak: %s", exc)
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  API KEY AUTH  (B2B)
+# ══════════════════════════════════════════════════════════════════════
+api_key_header = APIKeyHeader(name="X-API-Key", auto_error=False)
+
+
+def verify_api_key(api_key: str = Security(api_key_header)):
+    if not api_key:
+        return None
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT * FROM api_keys WHERE api_key=? AND active=1", (api_key,)
+            ).fetchone()
+        return dict(row) if row else None
+    except Exception:
+        return None
+
+
+def generate_api_key(client_name: str, plan: str = "business") -> str:
+    key = "eak_" + secrets.token_urlsafe(32)
+    with db_conn() as conn:
+        conn.execute(
+            "INSERT INTO api_keys(api_key,client_name,plan) VALUES(?,?,?)",
+            (key, client_name, plan)
+        )
+    return key
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  GROQ CLIENT + LLM ABSTRACTION (Playbook: swap provider in one line)
+# ══════════════════════════════════════════════════════════════════════
+GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
+if not GROQ_API_KEY:
+    logger.warning("⚠️  GROQ_API_KEY missing — analysis will fail")
+    _groq_client = None
+else:
+    _groq_client = Groq(api_key=GROQ_API_KEY)
+
+
+def call_llm(prompt: str, max_tokens: int = 2500) -> str:
+    """
+    LLM abstraction layer — tries 70B then falls back to 8B.
+    Swap providers by changing this one function only.
+    """
+    if not _groq_client:
+        raise RuntimeError("GROQ_API_KEY not configured")
+    for model in ["llama-3.3-70b-versatile", "llama-3.1-8b-instant"]:
+        try:
+            comp = _groq_client.chat.completions.create(
+                model=model,
+                messages=[{"role": "user", "content": prompt}],
+                temperature=0.1,
+                max_tokens=max_tokens,
+                response_format={"type": "json_object"},
+            )
+            return comp.choices[0].message.content
+        except Exception as exc:
+            logger.warning("LLM model %s failed: %s — trying next", model, exc)
+    raise RuntimeError("All LLM models failed")
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  LAZY EASYOCR (no 30s startup freeze)
+# ══════════════════════════════════════════════════════════════════════
+_LANG_READERS      : dict = {}
+_LANG_READERS_LOCK        = threading.Lock()
+_EASYOCR_LANG_MAP         = {
+    "en": ["en"], "hi": ["en", "hi"], "zh": ["en", "ch_sim"],
+    "ta": ["en", "ta"], "te": ["en", "te"], "bn": ["en", "bn"],
+}
+
+
+def get_reader_for(lang_hint: str):
+    langs = _EASYOCR_LANG_MAP.get(lang_hint, ["en"])
+    key   = "_".join(sorted(langs))
+    if key not in _LANG_READERS:
+        with _LANG_READERS_LOCK:
+            if key not in _LANG_READERS:
+                import easyocr as _easyocr
+                logger.info("Loading EasyOCR for langs=%s (first request)", langs)
+                _LANG_READERS[key] = _easyocr.Reader(
+                    langs, gpu=False, model_storage_directory=MODEL_DIR)
+    return _LANG_READERS[key]
+
+
+def get_device_key(request: Request) -> str:
+    ip = request.client.host if request.client else "unknown"
+    ua = request.headers.get("user-agent", "")
+    return hashlib.md5(f"{ip}:{ua}".encode()).hexdigest()[:16]
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  BLUR DETECTION
+# ══════════════════════════════════════════════════════════════════════
+def _laplacian_score(gray: np.ndarray) -> float:
+    return float(cv2.Laplacian(gray, cv2.CV_64F).var())
+
+
+def _tenengrad_score(gray: np.ndarray) -> float:
+    gx = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
+    gy = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
+    return float(np.mean(gx ** 2 + gy ** 2))
+
+
+def _brenner_score(gray: np.ndarray) -> float:
+    diff = gray[:, 2:].astype(np.float64) - gray[:, :-2].astype(np.float64)
+    return float(np.mean(diff ** 2))
+
+
+def _local_blur_map(gray: np.ndarray, block: int = 64) -> float:
+    h, w   = gray.shape
+    scores = [
+        cv2.Laplacian(gray[y:y + block, x:x + block], cv2.CV_64F).var()
+        for y in range(0, h - block, block)
+        for x in range(0, w - block, block)
+    ]
+    return float(np.median(scores)) if scores else 0.0
+
+
+def assess_image_quality(content: bytes) -> dict:
+    try:
+        img    = Image.open(BytesIO(content)).convert("RGB")
+        img_np = np.array(img)
+        gray   = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+
+        lap  = _laplacian_score(gray)
+        ten  = _tenengrad_score(gray)
+        bren = _brenner_score(gray)
+        loc  = _local_blur_map(gray)
+
+        comp = (
+            0.25 * min(lap  / 300.0 * 100, 100) +
+            0.20 * min(ten  / 500.0 * 100, 100) +
+            0.20 * min(bren / 200.0 * 100, 100) +
+            0.35 * min(loc  / 300.0 * 100, 100)
+        )
+
+        if comp < 15:   severity, is_blurry = "severe",   True
+        elif comp < 35: severity, is_blurry = "moderate", True
+        elif comp < 55: severity, is_blurry = "mild",     True
+        else:           severity, is_blurry = "none",     False
+
+        return {
+            "blur_score"  : round(comp, 2),
+            "is_blurry"   : is_blurry,
+            "blur_severity": severity,
+            "quality"     : "poor" if comp < 35 else ("fair" if comp < 55 else "good"),
+        }
+    except Exception as exc:
+        logger.error("Blur detection error: %s", exc)
+        return {"blur_score": 999, "is_blurry": False, "blur_severity": "unknown", "quality": "unknown"}
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  DEBLURRING PIPELINE
+# ══════════════════════════════════════════════════════════════════════
+def _wiener_deconvolution(gray: np.ndarray, psf_size: int = 5,
+                          noise_ratio: float = 0.02) -> np.ndarray:
+    psf_size = max(3, psf_size | 1)
+    psf = cv2.getGaussianKernel(psf_size, psf_size / 3.0)
+    psf = psf @ psf.T; psf /= psf.sum()
+    h, w   = gray.shape
+    padded = np.zeros_like(gray, dtype=np.float64)
+    ph, pw = psf.shape
+    padded[:ph, :pw] = psf
+    padded = np.roll(np.roll(padded, -ph // 2, axis=0), -pw // 2, axis=1)
+    Y      = np.fft.fft2(gray.astype(np.float64) / 255.0)
+    H      = np.fft.fft2(padded)
+    Hc     = np.conj(H)
+    W      = Hc / (np.abs(H) ** 2 + noise_ratio)
+    return np.clip(np.real(np.fft.ifft2(W * Y)) * 255.0, 0, 255).astype(np.uint8)
+
+
+def _unsharp_mask(img_np: np.ndarray, strength: float = 1.5, radius: int = 3) -> np.ndarray:
+    blurred = cv2.GaussianBlur(img_np, (radius * 2 + 1, radius * 2 + 1), 0)
+    mask    = cv2.subtract(img_np.astype(np.int16), blurred.astype(np.int16))
+    return np.clip(img_np.astype(np.float32) + strength * mask, 0, 255).astype(np.uint8)
+
+
+def _apply_clahe(img_np: np.ndarray, clip: float = 2.5, tile: int = 8) -> np.ndarray:
+    lab = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB)
+    cl  = cv2.createCLAHE(clipLimit=clip, tileGridSize=(tile, tile))
+    lab[:, :, 0] = cl.apply(lab[:, :, 0])
+    return cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+
+
+def _denoise(img_np: np.ndarray, h: int = 6) -> np.ndarray:
+    bgr = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
+    return cv2.cvtColor(
+        cv2.fastNlMeansDenoisingColored(bgr, None, h, h, 7, 21),
+        cv2.COLOR_BGR2RGB
+    )
+
+
+def deblur_and_enhance(content: bytes, severity: str = "moderate"):
+    """Full 6-stage deblur pipeline. Returns (enhanced_bytes, method_log)."""
+    img    = Image.open(BytesIO(content)).convert("RGB")
+    img_np = np.array(img)
+    log    = []
+
+    h, w = img_np.shape[:2]
+    if min(h, w) < 1200:
+        scale  = 1200 / min(h, w)
+        img_np = cv2.resize(img_np, (int(w * scale), int(h * scale)),
+                            interpolation=cv2.INTER_LANCZOS4)
+        log.append("upscale")
+
+    if severity in ("severe", "moderate"):
+        h_p = 8 if severity == "severe" else 5
+        img_np = _denoise(img_np, h=h_p)
+        log.append(f"NLM(h={h_p})")
+
+    if severity != "mild":
+        gray          = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+        psf           = 9 if severity == "severe" else 5
+        kr            = 0.01 if severity == "severe" else 0.025
+        rest          = _wiener_deconvolution(gray, psf, kr)
+        lab           = cv2.cvtColor(img_np, cv2.COLOR_RGB2LAB)
+        lab[:, :, 0]  = rest
+        img_np        = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+        log.append(f"Wiener(psf={psf})")
+
+    sm = {"severe": 2.2, "moderate": 1.8, "mild": 1.2}
+    rm = {"severe": 4,   "moderate": 3,   "mild": 2}
+    img_np = _unsharp_mask(img_np, strength=sm.get(severity, 1.8),
+                           radius=rm.get(severity, 3))
+    log.append("unsharp")
+
+    cm = {"severe": 3.0, "moderate": 2.5, "mild": 1.8}
+    img_np = _apply_clahe(img_np, clip=cm.get(severity, 2.5))
+    log.append("CLAHE")
+
+    img_np = _unsharp_mask(img_np, strength=1.2, radius=2)
+    log.append("sharpen2")
+
+    # Assess enhancement quality
+    gray_orig = cv2.cvtColor(np.array(Image.open(BytesIO(content)).convert("RGB")),
+                             cv2.COLOR_RGB2GRAY)
+    orig_score = float(cv2.Laplacian(gray_orig, cv2.CV_64F).var())
+    gray_enh   = cv2.cvtColor(img_np, cv2.COLOR_RGB2GRAY)
+    enh_score  = float(cv2.Laplacian(gray_enh, cv2.CV_64F).var())
+    log.append(f"orig={orig_score:.0f} enh={enh_score:.0f}")
+
+    buf = BytesIO()
+    Image.fromarray(img_np).save(buf, format="JPEG", quality=92)
+    return buf.getvalue(), " → ".join(log)
+
+
+def _ocr_quality_score(ocr_result: dict) -> float:
+    return (ocr_result.get("word_count", 0) * 0.6 +
+            ocr_result.get("avg_confidence", 0) * 100 * 0.4)
+
+
+def image_to_b64(content: bytes) -> str:
+    return "data:image/jpeg;base64," + base64.b64encode(content).decode()
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  LABEL DETECTION  (front-of-pack vs nutrition label)
+# ══════════════════════════════════════════════════════════════════════
+LABEL_KEYWORDS = [
+    'ingredients', 'nutrition', 'nutritional', 'calories', 'calorie',
+    'protein', 'fat', 'carbohydrate', 'carbs', 'sodium', 'sugar', 'sugars',
+    'fiber', 'fibre', 'serving', 'cholesterol', 'saturated', 'trans',
+    'vitamin', 'calcium', 'iron', 'potassium', 'per 100g', 'per 100 g',
+    'daily value', 'daily values', 'amount per', 'total fat',
+    'contains', 'may contain', 'preservative', 'flavour', 'flavor',
+    'colour', 'color', 'emulsifier', 'stabilizer', 'antioxidant',
+    'mg', 'mcg', 'kcal', 'kj', '% dv', '%dv', 'g per', 'per serving',
+    'fssai', 'veg', 'non-veg', 'best before', 'mfg', 'mrp', 'net wt',
+    'manufactured', 'packed', 'distributed',
+]
+
+FRONT_PACK_SIGNALS = [
+    'new', 'improved', 'original', 'classic', 'natural', 'organic',
+    'premium', 'delicious', 'flavoured', 'variety', 'crunchy', 'crispy',
+    'fresh', 'tasty', 'yummy', 'light', 'baked', 'roasted',
+]
+
+# BUG FIX: Words like 'wheat','milk','salt' appear on front packs too.
+# Require at least 2 nutrition-table anchors to confirm a back label.
+NUTRITION_TABLE_ANCHORS = [
+    'per 100g', 'per 100 g', 'per serving', 'serving size', 'amount per',
+    'daily value', 'daily values', '% dv', '%dv',
+    'calories', 'calorie', 'kcal', 'kj', 'energy',
+    'nutrition facts', 'nutritional information', 'nutrition information',
+    'total fat', 'saturated fat', 'trans fat',
+    'total carbohydrate', 'dietary fiber', 'total sugars',
+    'ingredients:', 'ingredients list',
+    'fssai', 'best before', 'mfg', 'mrp', 'net wt',
+]
+
+
+def detect_label_presence(ocr_text: str) -> dict:
+    if not ocr_text:
+        return {'has_label': False, 'confidence': 'high',
+                'label_hits': [], 'front_hits': [], 'suggestion': 'no_text'}
+    tl           = ocr_text.lower()
+    label_hits   = [kw for kw in LABEL_KEYWORDS         if kw in tl]
+    front_hits   = [kw for kw in FRONT_PACK_SIGNALS     if kw in tl]
+    anchor_hits  = [kw for kw in NUTRITION_TABLE_ANCHORS if kw in tl]
+    label_score  = len(label_hits)
+    front_score  = len(front_hits)
+    has_table    = len(anchor_hits) >= 2
+
+    if has_table and label_score >= 3:
+        return {'has_label': True,
+                'confidence': 'high' if label_score >= 6 else 'medium',
+                'label_hits': label_hits[:5], 'front_hits': front_hits[:3],
+                'suggestion': None}
+    elif has_table and label_score >= 1 and front_score <= 2:
+        return {'has_label': True, 'confidence': 'low',
+                'label_hits': label_hits, 'front_hits': front_hits,
+                'suggestion': None}
+    elif front_score > label_score or not has_table:
+        sug = 'wrong_side' if (front_score > 0 or not has_table) else 'no_label'
+        return {'has_label': False, 'confidence': 'high',
+                'label_hits': label_hits, 'front_hits': front_hits[:3],
+                'suggestion': sug}
+    else:
+        return {'has_label': True, 'confidence': 'low',
+                'label_hits': label_hits, 'front_hits': front_hits,
+                'suggestion': 'partial'}
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  OCR  (SQLite cache)
+# ══════════════════════════════════════════════════════════════════════
+def get_server_ocr(content: bytes, lang_hint: str = "en") -> dict:
+    cache_key = f"{hashlib.md5(content).hexdigest()}_{lang_hint}"
+    cached    = get_ocr_cache(cache_key)
+    if cached:
+        return cached
+
+    img = Image.open(BytesIO(content)).convert("RGB")
+    img.thumbnail((1200, 1200))
+    img_np      = np.array(img)
+    ocr_reader  = get_reader_for(lang_hint)
+    results     = ocr_reader.readtext(img_np, detail=1)
+    words       = [r[1] for r in results]
+    confidences = [r[2] for r in results]
+    text        = " ".join(words)
+    avg_conf    = sum(confidences) / len(confidences) if confidences else 0.0
+
+    result = {
+        "text"          : text,
+        "word_count"    : len(words),
+        "avg_confidence": round(avg_conf, 3),
+        "is_readable"   : len(words) >= 3 and avg_conf > 0.15,
+    }
+    set_ocr_cache(cache_key, result)
+    return result
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  WEB SEARCH  (guarded)
+# ══════════════════════════════════════════════════════════════════════
+def get_live_search(query: str) -> str:
+    if not _DDGS_OK:
+        return "Web search unavailable."
+    try:
+        with _DDGS() as ddgs:
+            results = [f"{r['title']}: {r['body']}"
+                       for r in ddgs.text(query, max_results=3)]
+        return "\n".join(results) if results else "No web data available."
+    except Exception as exc:
+        logger.warning("Web search failed: %s", exc)
+        return "No web data available."
+
+
+LANGUAGE_MAP = {
+    "en": "English",      "zh": "Simplified Chinese (简体中文)",
+    "es": "Spanish",      "ar": "Arabic",
+    "fr": "French",       "hi": "Hindi (हिन्दी)",
+    "pt": "Portuguese",   "de": "German",
+}
+
+
+# ══════════════════════════════════════════════════════════════════════
+#  ROUTES
+# ══════════════════════════════════════════════════════════════════════
+@app.get("/")
+async def home():
+    return FileResponse("index.html")
+
+
+@app.get("/health")
+async def health():
+    return {"status": "ok", "version": APP_VERSION}
+
+
+@app.post("/check-image")
+@limiter.limit("30/minute")
+async def check_image(request: Request, image: UploadFile = File(...)):
+    content = await image.read()
+    return assess_image_quality(content)
+
+
+@app.post("/enhance-preview")
+@limiter.limit("20/minute")
+async def enhance_preview(request: Request, image: UploadFile = File(...)):
+    content = await image.read()
+    quality = assess_image_quality(content)
+    if not quality["is_blurry"]:
+        return JSONResponse({"deblurred": False, "message": "Image already clear.", "quality": quality})
+    enhanced_bytes, method_log = deblur_and_enhance(content, quality["blur_severity"])
+    return JSONResponse({
+        "deblurred"    : True,
+        "image_b64"    : image_to_b64(enhanced_bytes),
+        "method_log"   : method_log,
+        "blur_severity": quality["blur_severity"],
+        "quality_before": quality,
+    })
+
+
+@app.post("/ocr")
+@limiter.limit("20/minute")
+async def perform_ocr(request: Request, image: UploadFile = File(...),
+                      language: str = Form("en")):
+    content = await image.read()
+    return get_server_ocr(content, language)
+
+
+# ── Main analysis route ────────────────────────────────────────────────
+@app.post("/analyze")
+@limiter.limit("15/minute")
+async def analyze_product(
+    request          : Request,
+    persona          : str        = Form(...),
+    age_group        : str        = Form("adult"),
+    product_category : str        = Form("general"),
+    language         : str        = Form("en"),
+    extracted_text   : str        = Form(None),
+    image            : UploadFile = File(...),
+):
+    if not _groq_client:
+        return JSONResponse({"error": "Server error: GROQ_API_KEY not set"})
+
+    device_key = get_device_key(request)
+    scan_check = check_and_increment_scan(device_key)
+    if not scan_check["allowed"]:
+        return JSONResponse(status_code=402, content={
+            "error"      : "scan_limit_reached",
+            "message"    : f"You've used all {FREE_SCAN_LIMIT} free scans this month.",
+            "upgrade_url": "/pro",
+        })
+
+    try:
+        content   = await image.read()
+        quality   = assess_image_quality(content)
+        blur_info = {
+            "detected" : quality["is_blurry"],
+            "severity" : quality["blur_severity"],
+            "score"    : quality["blur_score"],
+            "deblurred": False, "method_log": None,
+            "image_b64": None,  "ocr_source": "original",
+        }
+        working = content
+
+        # Deblur
+        if quality["is_blurry"]:
+            try:
+                enhanced, method_log = deblur_and_enhance(content, quality["blur_severity"])
+                if (_ocr_quality_score(get_server_ocr(enhanced, language)) >=
+                        _ocr_quality_score(get_server_ocr(content, language)) * 0.85):
+                    working                   = enhanced
+                    blur_info["deblurred"]    = True
+                    blur_info["method_log"]   = method_log
+                    blur_info["image_b64"]    = image_to_b64(enhanced)
+                    blur_info["ocr_source"]   = "deblurred"
+                    extracted_text            = None
+            except Exception as exc:
+                logger.warning("Deblur failed: %s", exc)
+
+        # OCR
+        if not extracted_text:
+            ocr_result     = get_server_ocr(working, language)
+            extracted_text = ocr_result["text"]
+            ocr_word_count = ocr_result["word_count"]
+        else:
+            ocr_word_count = len(extracted_text.split())
+
+        if not extracted_text or ocr_word_count == 0:
+            return JSONResponse({"error": "no_text",
+                "message": "No text found. Make sure the label side is facing the camera.",
+                "tip": "flip_product"})
+
+        label_check = detect_label_presence(extracted_text)
+        if not label_check["has_label"]:
+            tip = label_check["suggestion"] or "flip_product"
+            msg = ("This looks like the front of the product. Flip it over and scan the back label."
+                   if tip == "wrong_side"
+                   else "Could not find nutrition or ingredient information.")
+            return JSONResponse({"error": "no_label", "message": msg, "tip": tip,
+                                 "front_words_found": label_check.get("front_hits", [])})
+
+        label_confidence = label_check.get("confidence", "medium")
+
+        # Cache lookup — v3 prefix busts all old score=6 results
+        cache_key     = f"v3:{language}:{persona}:{age_group}:{extracted_text[:80]}"
+        cached_result = get_ai_cache(cache_key)
+        if cached_result:
+            cached_result["blur_info"] = blur_info
+            cached_result["scan_meta"] = scan_check
+            return JSONResponse(cached_result)
+
+        # Web search (non-blocking)
+        web_context = await asyncio.to_thread(
+            get_live_search, f"health analysis ingredients {extracted_text[:120]}")
+
+        # Allergen profile check
+        allergen_warning = ""
+        try:
+            with db_conn() as conn:
+                row = conn.execute(
+                    "SELECT allergens, conditions FROM allergen_profiles WHERE device_key=?",
+                    (device_key,)
+                ).fetchone()
+            if row:
+                user_allergens  = json.loads(row["allergens"]  or "[]")
+                user_conditions = json.loads(row["conditions"] or "[]")
+                tl              = extracted_text.lower()
+                triggered = [a for a in user_allergens  if a.lower() in tl] + \
+                            [c for c in user_conditions if c.lower() in tl]
+                if triggered:
+                    allergen_warning = (
+                        f"⚠️ ALLERGEN ALERT — This product may contain: "
+                        f"{', '.join(triggered)}. Based on your profile."
+                    )
+        except Exception as exc:
+            logger.warning("Allergen check: %s", exc)
+
+        # Build prompt
+        lang_name       = LANGUAGE_MAP.get(language, "English")
+        confidence_note = (
+            "⚠️ Label text may be partial — only list nutrients you can read confidently."
+            if label_confidence == "low" else ""
+        )
+        blur_context = ""
+        if blur_info["detected"]:
+            verb         = "enhanced" if blur_info["deblurred"] else "blurry (original used)"
+            blur_context = f"IMAGE: {blur_info['severity']}ly blurry ({verb}). Only report confident values."
+
+        prompt = f"""[INST]
+You are an expert nutritional scientist and food safety auditor.
+CRITICAL: Respond ENTIRELY in {lang_name}. Every text field MUST be in {lang_name}.
+Persona: {persona} | Age: {age_group} | Category: {product_category}
+{confidence_note}
+{blur_context}
+Label Text: "{extracted_text}"
+Web Context: "{web_context}"
+
+Return ONLY valid JSON — no markdown, no preamble:
+{{
+  "product_name"      : "Short name from label",
+  "product_category"  : "Snack|Dairy|Beverage|Cereal|Supplement|etc.",
+  "score"             : <INTEGER 1-10 — MUST match SCORING RUBRIC below>,
+  "verdict"           : "Two-word verdict in {lang_name}",
+  "chart_data"        : [<Safe%>, <Moderate%>, <Risky%>],
+  "summary"           : "2-sentence professional summary in {lang_name}.",
+  "eli5_explanation"  : "Child-friendly explanation with emojis in {lang_name}.",
+  "molecular_insight" : "1-2 sentences on biochemical body impact in {lang_name}.",
+  "paragraph_benefits": "Full paragraph on genuine benefits in {lang_name}.",
+  "paragraph_uniqueness": "Unique characteristics OR 2 better alternatives in {lang_name}.",
+  "is_unique"         : true,
+  "nutrient_breakdown": [
+    {{"name":"Protein",  "value":<ACTUAL g from label>, "unit":"g",  "rating":"good",    "impact":"brief note in {lang_name}"}},
+    {{"name":"Sugar",    "value":<ACTUAL g>,            "unit":"g",  "rating":"moderate","impact":"brief note in {lang_name}"}},
+    {{"name":"Fat",      "value":<ACTUAL g>,            "unit":"g",  "rating":"good",    "impact":"brief note in {lang_name}"}},
+    {{"name":"Sodium",   "value":<ACTUAL mg>,           "unit":"mg", "rating":"caution", "impact":"brief note in {lang_name}"}},
+    {{"name":"Fiber",    "value":<ACTUAL g>,            "unit":"g",  "rating":"good",    "impact":"brief note in {lang_name}"}}
+  ],
+  "pros"            : ["Benefit 1 in {lang_name}", "Benefit 2", "Benefit 3"],
+  "cons"            : ["Risk 1 in {lang_name}", "Risk 2"],
+  "age_warnings"    : [
+    {{"group":"Children","emoji":"👶","status":"warning","message":"in {lang_name}"}},
+    {{"group":"Adults",  "emoji":"🧑","status":"good",   "message":"in {lang_name}"}},
+    {{"group":"Seniors", "emoji":"👴","status":"caution","message":"in {lang_name}"}},
+    {{"group":"Pregnant","emoji":"🤰","status":"caution","message":"in {lang_name}"}}
+  ],
+  "better_alternative": "A specific healthier alternative in {lang_name}.",
+  "is_low_confidence" : false
+}}
+
+SCORING RUBRIC — score MUST match actual label data, NEVER default to 6 or 7:
+  9-10: Whole food, no added sugar, low sodium, high fibre/protein
+  7-8 : Mildly processed, sugar <5g/100g, reasonable sodium
+  5-6 : Processed, sugar 5-15g/100g OR sodium 400-700mg/100g
+  3-4 : High sugar >15g/100g OR sodium >700mg/100g OR poor profile
+  1-2 : Ultra-processed, very high sugar/sodium/sat-fat
+
+RULES:
+- score MUST match actual nutrient values — NEVER use 6 or 7 as default
+- chart_data must sum to exactly 100
+- nutrient rating: "good"|"moderate"|"caution"|"bad"
+- age_warnings status: "good"|"caution"|"warning"
+- Extract ACTUAL values from label — never use placeholder numbers
+- ALL text values MUST be in {lang_name}
+[/INST]"""
+
+        # LLM call (non-blocking)
+        raw_json = await asyncio.to_thread(call_llm, prompt, 2500)
+        result   = json.loads(raw_json)
+
+        # ── Validate & sanitise ────────────────────────────────────────
+        # chart_data: always sums to exactly 100
+        cd = result.get("chart_data")
+        if isinstance(cd, list) and len(cd) == 3 and all(isinstance(x, (int, float)) for x in cd):
+            total = sum(cd)
+            if total > 0 and total != 100:
+                scaled = [round(v * 100 / total) for v in cd]
+                scaled[scaled.index(max(scaled))] += 100 - sum(scaled)
+                result["chart_data"] = scaled
+        else:
+            result["chart_data"] = [70, 20, 10]
+
+        # Strip unit chars from nutrient values ("34g" → 34.0)
+        for n in result.get("nutrient_breakdown", []):
+            m = re.search(r"[\d]+\.?[\d]*", str(n.get("value", "")).replace(",", "."))
+            if m:
+                n["value"] = float(m.group())
+
+        # Safe defaults
+        result.setdefault("score",             5)
+        result.setdefault("verdict",           "Analyzed")
+        result.setdefault("product_name",      "Unknown Product")
+        result.setdefault("nutrient_breakdown", [])
+        result.setdefault("pros",              [])
+        result.setdefault("cons",              [])
+        result.setdefault("age_warnings",      [])
+        result.setdefault("is_low_confidence", False)
+
+        # Attach disclaimer + allergen alert
+        result["disclaimer"]       = MEDICAL_DISCLAIMER
+        result["allergen_warning"] = allergen_warning
+        result["blur_info"]        = blur_info
+        result["scan_meta"]        = scan_check
+
+        # ── Auto-log to daily tracker (Playbook: "the business") ──────
+        today   = datetime.date.today().isoformat()
+        pname   = result.get("product_name", "Scanned item")
+        nutr    = {n["name"].lower(): float(n.get("value", 0))
+                   for n in result.get("nutrient_breakdown", [])
+                   if isinstance(n.get("value"), (int, float))}
+        cal  = nutr.get("energy", nutr.get("calories", nutr.get("calorie", 0)))
+        prot = nutr.get("protein", 0)
+        carb = nutr.get("carbohydrate", nutr.get("carbs", nutr.get("total carbohydrate", 0)))
+        fat  = nutr.get("fat", nutr.get("total fat", 0))
+        sod  = nutr.get("sodium", 0)
+        fib  = nutr.get("fiber", nutr.get("fibre", nutr.get("dietary fiber", 0)))
+        sug  = nutr.get("sugar", nutr.get("sugars", nutr.get("total sugars", 0)))
+
+        try:
+            with db_conn() as conn:
+                conn.execute(
+                    """INSERT INTO daily_logs
+                       (device_key,log_date,meal_name,calories,protein,carbs,
+                        fat,sodium,fiber,sugar,source)
+                       VALUES(?,?,?,?,?,?,?,?,?,?,?)""",
+                    (device_key, today, pname, cal, prot, carb, fat, sod, fib, sug, "scan")
+                )
+                conn.execute(
+                    """INSERT INTO scans
+                       (device_key,product_name,score,verdict,calories,protein,
+                        carbs,fat,sodium,fiber,sugar,persona,language,analysis_json)
+                       VALUES(?,?,?,?,?,?,?,?,?,?,?,?,?,?)""",
+                    (device_key, pname, result.get("score", 0), result.get("verdict", ""),
+                     cal, prot, carb, fat, sod, fib, sug, persona, language,
+                     json.dumps({k: v for k, v in result.items()
+                                 if k not in ("blur_info", "scan_meta",
+                                              "disclaimer", "allergen_warning")}))
+                )
+        except Exception as exc:
+            logger.warning("Auto-log failed: %s", exc)
+
+        update_streak(device_key)
+
+        # Cache (without ephemeral fields)
+        cacheable = {k: v for k, v in result.items()
+                     if k not in ("blur_info", "scan_meta", "allergen_warning")}
+        set_ai_cache(cache_key, cacheable)
+
+        return JSONResponse(result)
+
+    except Exception as exc:
+        logger.error("Analysis error: %s", exc, exc_info=True)
+        return JSONResponse({"error": f"Scan failed: {str(exc)[:140]}. Please try again."})
+
+
+# ── Scan status ────────────────────────────────────────────────────────
+@app.get("/scan-status")
+async def scan_status(request: Request):
+    device_key = get_device_key(request)
+    _ensure_device(device_key)
+    month_key  = datetime.date.today().isoformat()[:7]
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT is_pro, month, scan_count, streak_days, last_scan_date "
+                "FROM devices WHERE device_key=?", (device_key,)
+            ).fetchone()
+        if not row or row["month"] != month_key:
+            return {"scans_used": 0, "scans_remaining": FREE_SCAN_LIMIT,
+                    "is_pro": False, "limit": FREE_SCAN_LIMIT, "streak": 0}
+        used = row["scan_count"]
+        return {"scans_used": used,
+                "scans_remaining": 9999 if row["is_pro"] else max(0, FREE_SCAN_LIMIT - used),
+                "is_pro": bool(row["is_pro"]),
+                "limit": FREE_SCAN_LIMIT,
+                "streak": row["streak_days"],
+                "last_scan_date": row["last_scan_date"]}
+    except Exception as exc:
+        logger.error("scan_status: %s", exc)
+        return {"scans_used": 0, "scans_remaining": FREE_SCAN_LIMIT, "is_pro": False, "limit": FREE_SCAN_LIMIT, "streak": 0}
+
+
+# ── Pro activation ─────────────────────────────────────────────────────
+@app.post("/activate-pro")
+async def activate_pro(request: Request, payment_id: str = Form(...)):
+    """Marks device as Pro. Replace demo_ check with real Razorpay verification."""
+    device_key = get_device_key(request)
+    _ensure_device(device_key)
+    month_key  = datetime.date.today().isoformat()[:7]
+    with db_conn() as conn:
+        conn.execute(
+            "UPDATE devices SET is_pro=1, month=? WHERE device_key=?",
+            (month_key, device_key)
+        )
+    logger.info("Pro activated device=%s payment_id=%s", device_key, payment_id)
+    return {"status": "activated", "message": "Pro activated! Unlimited scans unlocked."}
+
+
+# ── Onboarding ─────────────────────────────────────────────────────────
+@app.post("/onboarding-complete")
+async def onboarding_complete(
+    request  : Request,
+    persona  : str   = Form("General Adult"),
+    language : str   = Form("en"),
+    tdee     : float = Form(0),
+    allergens: str   = Form("[]"),
+):
+    device_key = get_device_key(request)
+    _ensure_device(device_key)
+    with db_conn() as conn:
+        conn.execute(
+            "UPDATE devices SET onboarding_done=1, persona=?, language=?, tdee=? WHERE device_key=?",
+            (persona, language, tdee, device_key)
+        )
+        conn.execute(
+            "INSERT OR REPLACE INTO allergen_profiles(device_key,allergens) VALUES(?,?)",
+            (device_key, allergens)
+        )
+    return {"status": "ok"}
+
+
+# ── Daily summary ──────────────────────────────────────────────────────
+@app.get("/daily-summary")
+async def daily_summary(request: Request, date: str = None):
+    """Today's macro totals vs TDEE + smart food suggestion."""
+    device_key  = get_device_key(request)
+    _ensure_device(device_key)
+    target_date = date or datetime.date.today().isoformat()
+    try:
+        with db_conn() as conn:
+            dev  = conn.execute(
+                "SELECT tdee FROM devices WHERE device_key=?", (device_key,)
+            ).fetchone()
+            row  = conn.execute(
+                """SELECT SUM(calories) cal, SUM(protein) prot, SUM(carbs) carb,
+                          SUM(fat) fat, SUM(sodium) sod, SUM(fiber) fib, SUM(sugar) sug,
+                          COUNT(*) items
+                   FROM daily_logs WHERE device_key=? AND log_date=?""",
+                (device_key, target_date)
+            ).fetchone()
+            log_items = conn.execute(
+                """SELECT id, meal_name, calories, protein, carbs, fat, sodium, source, logged_at
+                   FROM daily_logs WHERE device_key=? AND log_date=?
+                   ORDER BY logged_at DESC""",
+                (device_key, target_date)
+            ).fetchall()
+
+        tdee   = float(dev["tdee"] or 2000) if dev and dev["tdee"] else 2000
+        totals = {
+            "calories": round(row["cal"]  or 0, 1),
+            "protein" : round(row["prot"] or 0, 1),
+            "carbs"   : round(row["carb"] or 0, 1),
+            "fat"     : round(row["fat"]  or 0, 1),
+            "sodium"  : round(row["sod"]  or 0, 1),
+            "fiber"   : round(row["fib"]  or 0, 1),
+            "sugar"   : round(row["sug"]  or 0, 1),
+        }
+        targets = {
+            "calories": round(tdee), "protein": 56,
+            "carbs"   : round(tdee * 0.50 / 4),
+            "fat"     : round(tdee * 0.30 / 9),
+            "sodium"  : 2300, "fiber": 28, "sugar": 50,
+        }
+        remaining = {k: max(0, round(targets[k] - totals[k], 1)) for k in totals}
+        pct       = {k: min(100, round(totals[k] / targets[k] * 100)) if targets[k] else 0
+                     for k in totals}
+        cal_left  = remaining["calories"]
+        prot_left = remaining["protein"]
+        suggestion = ""
+        if cal_left < 200:
+            suggestion = "🎯 You've almost hit your calorie target for today — great tracking!"
+        elif prot_left > 20:
+            suggestion = f"💪 You need {prot_left}g more protein. Try: eggs, dal, paneer, or Greek yogurt."
+        elif cal_left > 600:
+            suggestion = f"🍽 You have {cal_left} kcal remaining. A balanced meal with lentils, rice & vegetables fits well."
+
+        return {
+            "date"      : target_date,
+            "totals"    : totals,
+            "targets"   : targets,
+            "remaining" : remaining,
+            "pct"       : pct,
+            "suggestion": suggestion,
+            "items"     : row["items"] or 0,
+            "log"       : [dict(r) for r in log_items],
+        }
+    except Exception as exc:
+        logger.error("daily_summary: %s", exc)
+        return {"date": target_date, "totals": {}, "targets": {}, "remaining": {}, "pct": {}, "suggestion": "", "items": 0, "log": []}
+
+
+# ── Daily log ──────────────────────────────────────────────────────────
+@app.post("/daily-log")
+@limiter.limit("30/minute")
+async def daily_log(
+    request  : Request,
+    meal_name: str   = Form(...),
+    calories : float = Form(0),
+    protein  : float = Form(0),
+    carbs    : float = Form(0),
+    fat      : float = Form(0),
+    sodium   : float = Form(0),
+    fiber    : float = Form(0),
+    sugar    : float = Form(0),
+    source   : str   = Form("manual"),
+    log_date : str   = Form(None),
+):
+    device_key  = get_device_key(request)
+    _ensure_device(device_key)
+    target_date = log_date or datetime.date.today().isoformat()
+    with db_conn() as conn:
+        conn.execute(
+            """INSERT INTO daily_logs
+               (device_key,log_date,meal_name,calories,protein,carbs,fat,sodium,fiber,sugar,source)
+               VALUES(?,?,?,?,?,?,?,?,?,?,?)""",
+            (device_key, target_date, meal_name,
+             calories, protein, carbs, fat, sodium, fiber, sugar, source)
+        )
+    return {"status": "logged", "date": target_date, "meal": meal_name}
+
+
+@app.delete("/daily-log/{log_id}")
+async def delete_daily_log(request: Request, log_id: int):
+    device_key = get_device_key(request)
+    with db_conn() as conn:
+        conn.execute(
+            "DELETE FROM daily_logs WHERE id=? AND device_key=?", (log_id, device_key)
+        )
+    return {"status": "deleted", "id": log_id}
+
+
+# ── Food search (OpenFoodFacts) ────────────────────────────────────────
+@app.get("/food-search")
+@limiter.limit("20/minute")
+async def food_search(request: Request, q: str = ""):
+    if not q or len(q) < 2:
+        return {"products": []}
+    try:
+        import httpx
+        async with httpx.AsyncClient(timeout=8) as hc:
+            resp = await hc.get(
+                "https://world.openfoodfacts.org/cgi/search.pl",
+                params={"search_terms": q, "action": "process", "json": 1,
+                        "page_size": 10,
+                        "fields": "product_name,nutriments,brands,serving_size"}
+            )
+        data = resp.json()
+        products = []
+        for p in data.get("products", []):
+            n = p.get("nutriments", {})
+            products.append({
+                "name"    : p.get("product_name", "Unknown"),
+                "brand"   : p.get("brands", ""),
+                "serving" : p.get("serving_size", "100g"),
+                "calories": round(n.get("energy-kcal_100g", 0), 1),
+                "protein" : round(n.get("proteins_100g", 0), 1),
+                "carbs"   : round(n.get("carbohydrates_100g", 0), 1),
+                "fat"     : round(n.get("fat_100g", 0), 1),
+                "sodium"  : round(n.get("sodium_100g", 0) * 1000, 1),
+                "fiber"   : round(n.get("fiber_100g", 0), 1),
+                "sugar"   : round(n.get("sugars_100g", 0), 1),
+            })
+        return {"products": products}
+    except Exception as exc:
+        logger.warning("food_search: %s", exc)
+        return {"products": [], "error": "Search unavailable"}
+
+
+# ── Allergen profile ───────────────────────────────────────────────────
+@app.get("/allergen-profile")
+async def get_allergen_profile(request: Request):
+    device_key = get_device_key(request)
+    try:
+        with db_conn() as conn:
+            row = conn.execute(
+                "SELECT allergens, conditions FROM allergen_profiles WHERE device_key=?",
+                (device_key,)
+            ).fetchone()
+        if not row:
+            return {"allergens": [], "conditions": []}
+        return {"allergens": json.loads(row["allergens"] or "[]"),
+                "conditions": json.loads(row["conditions"] or "[]")}
+    except Exception as exc:
+        logger.error("get_allergen_profile: %s", exc)
+        return {"allergens": [], "conditions": []}
+
+
+@app.post("/allergen-profile")
+async def set_allergen_profile(
+    request   : Request,
+    allergens : str = Form("[]"),
+    conditions: str = Form("[]"),
+):
+    device_key = get_device_key(request)
+    _ensure_device(device_key)
+    with db_conn() as conn:
+        conn.execute(
+            """INSERT OR REPLACE INTO allergen_profiles(device_key,allergens,conditions,updated_at)
+               VALUES(?,?,?,datetime('now'))""",
+            (device_key, allergens, conditions)
+        )
+    return {"status": "saved"}
+
+
+# ── NPS ────────────────────────────────────────────────────────────────
+@app.post("/nps")
+async def submit_nps(
+    request: Request,
+    score  : int = Form(...),
+    comment: str = Form(""),
+):
+    if not 0 <= score <= 10:
+        return JSONResponse({"error": "Score must be 0-10"}, status_code=400)
+    device_key = get_device_key(request)
+    with db_conn() as conn:
+        conn.execute(
+            "INSERT INTO nps_responses(device_key,score,comment) VALUES(?,?,?)",
+            (device_key, score, comment[:500])
+        )
+    return {"status": "thank_you"}
+
+
+# ── Admin analytics ────────────────────────────────────────────────────
+@app.get("/admin/analytics")
+async def admin_analytics(admin_token: str = ""):
+    # SECURITY: guard with ADMIN_TOKEN env var
+    expected = os.environ.get("ADMIN_TOKEN", "changeme")
+    if admin_token != expected:
+        raise HTTPException(status_code=403, detail="Invalid token")
+    today     = datetime.date.today().isoformat()
+    month_key = today[:7]
+    try:
+        with db_conn() as conn:
+            dau   = conn.execute(
+                "SELECT COUNT(DISTINCT device_key) FROM scans WHERE DATE(scanned_at)=?", (today,)
+            ).fetchone()[0]
+            mau   = conn.execute(
+                "SELECT COUNT(DISTINCT device_key) FROM scans WHERE strftime('%Y-%m',scanned_at)=?",
+                (month_key,)
+            ).fetchone()[0]
+            total = conn.execute("SELECT COUNT(*) FROM scans").fetchone()[0]
+            avg_s = conn.execute("SELECT AVG(score) FROM scans").fetchone()[0]
+            avg_n = conn.execute("SELECT AVG(score) FROM nps_responses").fetchone()[0]
+            nps_c = conn.execute("SELECT COUNT(*) FROM nps_responses").fetchone()[0]
+            top_p = conn.execute(
+                "SELECT product_name, COUNT(*) c FROM scans GROUP BY product_name ORDER BY c DESC LIMIT 10"
+            ).fetchall()
+        return {
+            "dau": dau, "mau": mau, "total_scans": total,
+            "avg_score": round(avg_s or 0, 2), "avg_nps": round(avg_n or 0, 2),
+            "nps_count": nps_c,
+            "dau_mau": round(dau / mau * 100, 1) if mau else 0,
+            "top_products": [{"name": r[0], "scans": r[1]} for r in top_p],
+        }
+    except Exception as exc:
+        logger.error("admin_analytics: %s", exc)
+        return {"error": str(exc)}
+
+
+# ── Share card (fixed anchor="mm" crash) ──────────────────────────────
+@app.post("/generate-share-card")
+@limiter.limit("20/minute")
+async def generate_share_card(
+    request     : Request,
+    product_name: str = Form(...),
+    score       : int = Form(...),
+    verdict     : str = Form(...),
+    top_warning : str = Form(""),
+    top_pro     : str = Form(""),
+):
+    W, H  = 1080, 1080
+    img   = Image.new("RGB", (W, H), (15, 17, 23))
+    draw  = ImageDraw.Draw(img)
+    font  = ImageFont.load_default()
+    s_rgb = (34, 197, 94) if score >= 7 else (245, 158, 11) if score >= 4 else (239, 68, 68)
+
+    def centered(text: str, y: int, fill):
+        """Center text — avoids anchor='mm' crash on bitmap fonts."""
+        try:
+            bbox = font.getbbox(text)
+            tw   = bbox[2] - bbox[0]
+        except AttributeError:
+            tw = len(text) * 6
+        draw.text(((W - tw) // 2, y), text, fill=fill, font=font)
+
+    draw.ellipse([340, 160, 740, 560], outline=s_rgb, width=18)
+    centered(str(score), 340, s_rgb)
+    centered("/10",      430, (100, 116, 139))
+    pname = product_name[:38] + ("…" if len(product_name) > 38 else "")
+    centered(pname,           600, (255, 255, 255))
+    centered(verdict[:50],    650, (148, 163, 184))
+    if top_pro:
+        draw.rectangle([60, 700, 1020, 760], fill=(15, 60, 40))
+        centered(f"✓ {top_pro[:65]}", 718, (74, 222, 128))
+    if top_warning:
+        draw.rectangle([60, 775, 1020, 840], fill=(124, 29, 29))
+        centered(f"⚠ {top_warning[:65]}", 795, (252, 165, 165))
+    centered("eatlytic.com  •  scan any food label, no barcode needed",
+             1000, (71, 85, 105))
+    draw.text((40, 1050), MEDICAL_DISCLAIMER[:90], fill=(50, 50, 60), font=font)
+
+    buf = BytesIO()
+    img.save(buf, format="PNG", optimize=True)
+    buf.seek(0)
+    return Response(content=buf.getvalue(), media_type="image/png",
+                    headers={"Content-Disposition": "attachment; filename=eatlytic-scan.png"})
+
+
+# ── PDF export (all reportlab bugs fixed) ─────────────────────────────
+@app.post("/export-pdf")
+@limiter.limit("10/minute")
+async def export_pdf(request: Request, analysis_json: str = Form(...)):
+    try:
+        data = json.loads(analysis_json)
+    except Exception:
+        return JSONResponse({"error": "Invalid JSON"}, status_code=400)
+    try:
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle
+        from reportlab.lib import colors as rl
+        from reportlab.lib.units import cm
+    except ImportError:
+        return JSONResponse({"error": "reportlab not installed"}, status_code=501)
+
+    buf  = BytesIO()
+    doc  = SimpleDocTemplate(buf, pagesize=A4,
+                              rightMargin=2*cm, leftMargin=2*cm,
+                              topMargin=2*cm, bottomMargin=2*cm)
+    stys  = getSampleStyleSheet()
+    story = []
+    story.append(Paragraph("Eatlytic Food Label Analysis", stys["Title"]))
+    story.append(Paragraph(f"Product: {data.get('product_name', 'Unknown')}", stys["Heading2"]))
+    story.append(Spacer(1, 0.3*cm))
+
+    score = data.get("score", 0)
+    sc    = "22c55e" if score >= 7 else "f59e0b" if score >= 4 else "ef4444"
+    story.append(Paragraph(
+        f"<font color='#{sc}'>Health Score: {score}/10 — {data.get('verdict','')}</font>",
+        stys["Heading1"]))
+    story.append(Paragraph(MEDICAL_DISCLAIMER,
+                            ParagraphStyle("disc", parent=stys["Normal"],
+                                           fontSize=8, textColor=rl.grey)))
+    story.append(Spacer(1, 0.4*cm))
+
+    if data.get("summary"):
+        story.append(Paragraph("Summary", stys["Heading2"]))
+        story.append(Paragraph(data["summary"], stys["Normal"]))
+        story.append(Spacer(1, 0.3*cm))
+
+    nutrients = data.get("nutrient_breakdown", [])
+    if nutrients:
+        story.append(Paragraph("Nutrient Breakdown", stys["Heading2"]))
+        tbl_data = [["Nutrient", "Amount", "Rating"]]
+        for n in nutrients:
+            val = n.get("value", "")
+            tbl_data.append([str(n.get("name", "")),
+                              f"{val} {n.get('unit', '')}".strip(),
+                              str(n.get("rating", "")).upper()])
+        tbl = Table(tbl_data, colWidths=[6*cm, 4*cm, 4*cm])
+        tbl.setStyle(TableStyle([
+            # FIX: HexColor does NOT accept '#' prefix
+            ("BACKGROUND",    (0, 0), (-1, 0),  rl.HexColor("1D9E75")),
+            ("TEXTCOLOR",     (0, 0), (-1, 0),  rl.white),
+            ("FONTSIZE",      (0, 0), (-1, -1), 10),
+            # FIX: ROWBACKGROUNDS is invalid; use BACKGROUND range instead
+            ("BACKGROUND",    (0, 1), (-1, -1), rl.HexColor("f8faf8")),
+            ("GRID",          (0, 0), (-1, -1), 0.4, rl.HexColor("d0d8d4")),
+            # FIX: PADDING is invalid; use TOP/BOTTOM/LEFT/RIGHTPADDING
+            ("TOPPADDING",    (0, 0), (-1, -1), 6),
+            ("BOTTOMPADDING", (0, 0), (-1, -1), 6),
+            ("LEFTPADDING",   (0, 0), (-1, -1), 8),
+            ("RIGHTPADDING",  (0, 0), (-1, -1), 8),
+        ]))
+        story.append(tbl)
+        story.append(Spacer(1, 0.4*cm))
+
+    if data.get("pros"):
+        story.append(Paragraph("Benefits", stys["Heading2"]))
+        for p in data["pros"]:
+            story.append(Paragraph(f"✓ {p}", stys["Normal"]))
+    if data.get("cons"):
+        story.append(Spacer(1, 0.3*cm))
+        story.append(Paragraph("Concerns", stys["Heading2"]))
+        for c in data["cons"]:
+            story.append(Paragraph(f"✗ {c}", stys["Normal"]))
+    if data.get("age_warnings"):
+        story.append(Spacer(1, 0.4*cm))
+        story.append(Paragraph("Age-Group Guidance", stys["Heading2"]))
+        for w in data["age_warnings"]:
+            story.append(Paragraph(
+                f"{w.get('emoji','')} {w.get('group','')} — {w.get('message','')}",
+                stys["Normal"]))
+    if data.get("better_alternative"):
+        story.append(Spacer(1, 0.3*cm))
+        story.append(Paragraph("Better Alternative", stys["Heading2"]))
+        story.append(Paragraph(data["better_alternative"], stys["Normal"]))
+
+    story.append(Spacer(1, 0.6*cm))
+    story.append(Paragraph("Generated by Eatlytic v3 — eatlytic.com",
+                            ParagraphStyle("footer", parent=stys["Normal"],
+                                           fontSize=8, textColor=rl.grey)))
+    try:
+        doc.build(story)
+    except Exception as exc:
+        logger.error("PDF build failed: %s", exc)
+        return JSONResponse({"error": f"PDF generation failed: {exc}"}, status_code=500)
+
+    buf.seek(0)
+    safe = data.get("product_name", "scan").replace(" ", "-")[:40]
+    return Response(content=buf.getvalue(), media_type="application/pdf",
+                    headers={"Content-Disposition": f"attachment; filename=eatlytic-{safe}.pdf"})
+
+
+# ── B2B API ────────────────────────────────────────────────────────────
+@app.post("/api/v1/analyze")
+@limiter.limit("60/minute")
+async def api_analyze(
+    request     : Request,
+    image       : UploadFile = File(...),
+    language    : str = Form("en"),
+    persona     : str = Form("general adult"),
+    age_group   : str = Form("adult"),
+    api_key_data: dict = Security(verify_api_key),
+):
+    if not api_key_data:
+        raise HTTPException(status_code=401, detail="Invalid API key")
+    if not api_key_data.get("active"):
+        raise HTTPException(status_code=403, detail="API key suspended")
+
+    month_key = datetime.date.today().isoformat()[:7]
+    LIMITS    = {"business": 1000, "enterprise": 99999}
+    limit     = LIMITS.get(api_key_data["plan"], 1000)
+    try:
+        with db_conn() as conn:
+            if api_key_data.get("month") != month_key:
+                conn.execute(
+                    "UPDATE api_keys SET month=?, scans_this_month=0 WHERE api_key=?",
+                    (month_key, api_key_data["api_key"])
+                )
+                api_key_data["scans_this_month"] = 0
+            if api_key_data["scans_this_month"] >= limit:
+                raise HTTPException(status_code=429, detail=f"Monthly limit ({limit}) reached")
+            conn.execute(
+                "UPDATE api_keys SET scans_this_month=scans_this_month+1 WHERE api_key=?",
+                (api_key_data["api_key"],)
+            )
+    except HTTPException:
+        raise
+    except Exception as exc:
+        logger.error("B2B quota: %s", exc)
+
+    content = await image.read()
+    quality = assess_image_quality(content)
+    working = content
+    if quality["is_blurry"]:
+        try:
+            enhanced, _ = deblur_and_enhance(content, quality["blur_severity"])
+            if (_ocr_quality_score(get_server_ocr(enhanced, language)) >=
+                    _ocr_quality_score(get_server_ocr(content, language)) * 0.85):
+                working = enhanced
+        except Exception:
+            pass
+
+    ocr  = get_server_ocr(working, language)
+    lc   = detect_label_presence(ocr["text"])
+    if not lc["has_label"]:
+        return JSONResponse({"error": "no_label"})
+
+    cache_key = f"b2b_v3:{language}:{persona}:{ocr['text'][:80]}"
+    cached    = get_ai_cache(cache_key)
+    if cached:
+        return JSONResponse(cached)
+
+    lang_name = LANGUAGE_MAP.get(language, "English")
+    web_ctx   = await asyncio.to_thread(
+        get_live_search, f"health ingredients {ocr['text'][:120]}")
+    prompt = (f"[INST] Analyze label: \"{ocr['text']}\". "
+              f"Web: \"{web_ctx}\". Persona: {persona}. "
+              f"Respond in {lang_name} as valid JSON: product_name, score(1-10), verdict, "
+              f"summary, nutrient_breakdown, pros, cons, age_warnings, better_alternative. [/INST]")
+    try:
+        raw    = await asyncio.to_thread(call_llm, prompt, 2000)
+        result = json.loads(raw)
+        result["disclaimer"] = MEDICAL_DISCLAIMER
+        set_ai_cache(cache_key, result)
+        return JSONResponse(result)
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Analysis failed: {str(exc)[:100]}")
+
+
+# ── Admin: create API key ──────────────────────────────────────────────
+@app.post("/admin/create-api-key")
+async def create_api_key_endpoint(
+    admin_token: str = Form(...),
+    client_name: str = Form(...),
+    plan       : str = Form("business"),
+):
+    if admin_token != os.environ.get("ADMIN_TOKEN", "changeme"):
+        raise HTTPException(status_code=403, detail="Invalid admin token")
+    key = generate_api_key(client_name, plan)
+    return {"api_key": key, "client": client_name, "plan": plan}
+
+
+# ── WhatsApp ───────────────────────────────────────────────────────────
+@app.post("/whatsapp-webhook")
+async def whatsapp_webhook(request: Request):
+    try:
+        from twilio.twiml.messaging_response import MessagingResponse
+    except ImportError:
+        return Response(
+            content="<Response><Message>twilio not installed.</Message></Response>",
+            media_type="application/xml")
+    form      = await request.form()
+    media_url = form.get("MediaUrl0")
+    resp      = MessagingResponse()
+    msg       = resp.message()
+    if media_url:
+        try:
+            import httpx
+            SID   = os.environ.get("TWILIO_ACCOUNT_SID", "")
+            TOKEN = os.environ.get("TWILIO_AUTH_TOKEN", "")
+            async with httpx.AsyncClient() as hc:
+                img_bytes = (await hc.get(media_url, auth=(SID, TOKEN))).content
+            quality = assess_image_quality(img_bytes)
+            if quality["is_blurry"]:
+                img_bytes, _ = deblur_and_enhance(img_bytes, quality["blur_severity"])
+            ocr_r = get_server_ocr(img_bytes, "en")
+            lc    = detect_label_presence(ocr_r["text"])
+            if not lc["has_label"]:
+                msg.body("❌ Couldn't find a nutrition label. Please send the *back* of the pack.")
+            elif not _groq_client:
+                msg.body("⚠️ AI unavailable. Full analysis at *eatlytic.com*")
+            else:
+                web_ctx = get_live_search(f"health ingredients {ocr_r['text'][:80]}")
+                prompt  = (f"5-bullet WhatsApp health summary of: \"{ocr_r['text'][:400]}\". "
+                           f"Start with score /10. Web context: {web_ctx}")
+                summary = await asyncio.to_thread(call_llm, prompt, 400)
+                msg.body(f"🔍 *Eatlytic Analysis*\n\n{summary}\n\n"
+                         f"_{MEDICAL_DISCLAIMER[:80]}_\n_Full: eatlytic.com_")
+        except Exception as exc:
+            logger.error("WhatsApp: %s", exc)
+            msg.body("⚠️ Something went wrong. Try again or visit *eatlytic.com*")
+    else:
+        msg.body("👋 Welcome to *Eatlytic*!\n\nSend a photo of any food label (back of pack). "
+                 "Works on blurry photos 📸 Free — no barcode needed.")
+    return Response(content=str(resp), media_type="application/xml")
+
+
+# ── OCR test ───────────────────────────────────────────────────────────
+@app.post("/test-accuracy")
+@limiter.limit("5/minute")
+async def test_accuracy(
+    request     : Request,
+    image       : UploadFile = File(...),
+    ground_truth: str = Form(""),
+):
+    content  = await image.read()
+    quality  = assess_image_quality(content)
+    ocr_orig = get_server_ocr(content, "en")
+    ocr_enh  = None
+    if quality["is_blurry"]:
+        try:
+            enhanced, _ = deblur_and_enhance(content, quality["blur_severity"])
+            ocr_enh     = get_server_ocr(enhanced, "en")
+        except Exception:
+            pass
+
+    def f1(pred: str, truth: str) -> float:
+        if not truth:
+            return 0.0
+        pw = set(pred.lower().split()); tw = set(truth.lower().split())
+        tp = len(pw & tw)
+        pr = tp / len(pw) if pw else 0; rc = tp / len(tw) if tw else 0
+        return round(2 * pr * rc / (pr + rc), 3) if (pr + rc) else 0.0
+
+    result = {
+        "blur_score"  : quality["blur_score"],
+        "blur_severity": quality["blur_severity"],
+        "is_blurry"   : quality["is_blurry"],
+        "original_ocr": {
+            "word_count"    : ocr_orig["word_count"],
+            "avg_confidence": ocr_orig["avg_confidence"],
+            "f1_vs_truth"   : f1(ocr_orig["text"], ground_truth),
+        },
+    }
+    if ocr_enh:
+        orig_f1 = f1(ocr_orig["text"], ground_truth)
+        enh_f1  = f1(ocr_enh["text"],  ground_truth)
+        result["enhanced_ocr"] = {
+            "word_count"    : ocr_enh["word_count"],
+            "avg_confidence": ocr_enh["avg_confidence"],
+            "f1_vs_truth"   : enh_f1,
+            "f1_delta"      : round(enh_f1 - orig_f1, 3),
+        }
+    return result