Final sweep: beautiful UI, pitch deck, HF README, ARCHITECTURE.md

UI overhaul:
- .streamlit/config.toml: Streamlit theme (navy primary, clean typography)
- ui/styles.py: comprehensive CSS — dark navy sidebar, metric cards with hover
lift, pill-style tab bar, gradient primary buttons, HTML verdict/category/OCR
tier badges, hero banner, custom confidence bars with green/amber/red coloring
- ui/components.py: HTML badge system (verdict_pill, category_badge,
ocr_tier_badge, mandatory_badge, confidence_bar with color thresholds)
- app.py: inject CSS, redesigned sidebar with glowing status dots and branding
- ui/tab_overview.py: hero banner, HTML KPI strip, styled pipeline stage cards
- ui/tab_bidders.py: HTML column headers, bidder header with pass/total count,
styled reason/snippet callout boxes
- ui/tab_review.py: HTML verdict display, friendly company names, styled cards
- ui/tab_interpretability.py: fix use_column_width for Streamlit 1.39.0

Submission:
- README.md: HuggingFace Spaces YAML frontmatter (sdk, emoji, colorFrom/To)
- ARCHITECTURE.md: full module responsibilities, OCR pipeline diagram,
confidence formula, threshold rules, audit schema, data flow
- scripts/generate_deck.py: 8-slide reportlab pitch deck
- deck/TenderIQ_Pitch.pdf: generated pitch deck

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

.streamlit/config.toml

@@ -0,0 +1,9 @@
+[theme]
+primaryColor = "#2563EB"
+backgroundColor = "#F8FAFC"
+secondaryBackgroundColor = "#FFFFFF"
+textColor = "#0D1B2A"
+font = "sans serif"
+
+[browser]
+gatherUsageStats = false

ARCHITECTURE.md

@@ -0,0 +1,180 @@
+# TenderIQ — Architecture
+
+## Overview
+
+TenderIQ is a single-process Streamlit application that automates eligibility evaluation
+of bidders against government tender criteria. All state is local: SQLite for the audit
+log, ChromaDB (file-backed) for vector indices, and the filesystem for PDFs and cached
+OCR results. The only external dependency is the DeepSeek API.
+
+```
+┌──────────────────────────────────────────────────────────────────────┐
+│                         Streamlit App (app.py)                        │
+│                                                                        │
+│  Tab 1: Overview  Tab 2: Tender Analysis  Tab 3: Bidder Evaluation    │
+│  Tab 4: Human Review  Tab 5: Audit Log  Tab 6: Interpretability       │
+└────────────────────────────┬─────────────────────────────────────────┘
+                             │ calls
+        ┌────────────────────┼────────────────────┐
+        ▼                    ▼                    ▼
+ ┌────────────┐    ┌──────────────────┐   ┌──────────────┐
+ │ criteria_  │    │ bidder_processor │   │  evaluator   │
+ │ extractor  │    │  ocr_pipeline    │   │  fallback    │
+ └────┬───────┘    └────┬─────────────┘   └──────┬───────┘
+      │                 │                         │
+      ▼                 ▼                         ▼
+ ┌──────────┐    ┌─────────────┐         ┌──────────────┐
+ │ DeepSeek │    │  ChromaDB   │         │ DeepSeek LLM │
+ │   LLM    │    │ (vectors)   │◄────────│  (evaluate)  │
+ └──────────┘    └─────────────┘         └──────────────┘
+      │                 ▲
+      │                 │ index chunks
+      │          ┌──────┴──────┐
+      │          │ 3-tier OCR  │
+      │          │ PyMuPDF     │
+      │          │ Tesseract   │
+      │          │ Vision LLM  │
+      │          └─────────────┘
+      │
+      ▼
+ ┌──────────┐
+ │  audit   │ (SQLite, append-only)
+ └──────────┘
+```
+
+---
+
+## Module Responsibilities
+
+| Module | Responsibility |
+|---|---|
+| `core/config.py` | Environment loading, constants, paths |
+| `core/schemas.py` | Pydantic models: Criterion, Evidence, Verdict, AuditEntry |
+| `core/prompts.py` | LLM prompt strings (criteria extraction, evaluation, OCR) |
+| `core/llm_client.py` | DeepSeek API wrapper — `chat_json`, `chat_vision`, retry logic, `LLMUnavailable` |
+| `core/pdf_utils.py` | PyMuPDF: text extraction, text-PDF detection, page rendering |
+| `core/ocr_pipeline.py` | Three-tier OCR orchestrator, MD5-based result cache |
+| `core/chunker.py` | Text chunking for tender and bidder documents |
+| `core/vectorstore.py` | ChromaDB helpers: get/create collection, upsert, query |
+| `core/criteria_extractor.py` | Stage 1: tender PDF → `list[Criterion]` |
+| `core/bidder_processor.py` | Stage 2: bidder docs → chunks + evidence retrieval |
+| `core/evaluator.py` | Stage 3: per-criterion verdict with combined confidence |
+| `core/audit.py` | SQLite audit log: write and query |
+| `core/fallback.py` | Load pre-computed JSON when LLM unavailable |
+
+---
+
+## Three-Tier OCR Pipeline
+
+The robustness centrepiece. Handles typed PDFs, scanned PDFs, and photographs of documents.
+
+```
+Input file
+    │
+    ├─ Is image (PNG/JPG)?  ──────────────────────────────────┐
+    │                                                         │
+    └─ Is PDF?                                                ▼
+           │                                         Tier 2: Tesseract
+           ├─ is_text_pdf() == True                          │
+           │       │                              mean_conf ≥ 0.65?
+           │       ▼                                   │
+           │  Tier 1: PyMuPDF                    Yes ──┘     No
+           │  confidence = 1.0                              │
+           │  source_type = "text_pdf"                      ▼
+           │                                     Tier 3: DeepSeek Vision LLM
+           └─ is_text_pdf() == False             confidence = 0.95
+                   │                             source_type = "vision_llm"
+                   ▼
+           Render pages → Tier 2
+```
+
+Each `ExtractedPage` carries: `page`, `text`, `source_type`, `confidence`, `raw_tier_results`.
+Results cached under `.ocr_cache/<md5>.json`.
+
+---
+
+## Confidence & Threshold Logic
+
+Combined confidence weights LLM certainty against OCR quality:
+
+| OCR Tier | Formula |
+|---|---|
+| `text_pdf` | `combined = llm_confidence` |
+| `vision_llm` | `combined = 0.7 × llm_confidence + 0.3 × 0.95` |
+| `tesseract` | `combined = 0.6 × llm_confidence + 0.4 × tesseract_conf` |
+
+Safety threshold rules (applied in order):
+
+1. LLM returns `needs_review` → keep (regardless of confidence)
+2. `combined ≥ 0.80` → keep LLM verdict
+3. `0.55 ≤ combined < 0.80` AND verdict is `not_eligible` → downgrade to `needs_review`
+4. `combined < 0.55` → force `needs_review`
+
+**The core safety guarantee:** a bidder is never silently disqualified at medium or low confidence.
+
+---
+
+## Fallback Strategy
+
+Every live LLM call is wrapped in `try/except LLMUnavailable`. On failure:
+
+1. `audit.log("precomputed_fallback_used", ...)` is written
+2. `st.session_state["fallback_active"] = True` triggers the amber sidebar dot
+3. Data is loaded from `data/precomputed/*.json` (committed to the repo)
+
+This means the demo works even if the API is down, rate-limited, or the key is missing.
+
+---
+
+## Audit Log Schema
+
+```sql
+CREATE TABLE audit_log (
+    id             INTEGER PRIMARY KEY AUTOINCREMENT,
+    ts             TEXT NOT NULL,      -- UTC ISO timestamp
+    action         TEXT NOT NULL,      -- see action vocabulary below
+    actor          TEXT NOT NULL,      -- "system" or "officer"
+    model_version  TEXT,               -- e.g. "deepseek-chat@2026-05-07"
+    bidder_id      TEXT,
+    criterion_id   TEXT,
+    payload_json   TEXT                -- action-specific JSON payload
+);
+```
+
+Action vocabulary: `criteria_extracted`, `bidder_processed`, `criterion_evaluated`,
+`human_review_action`, `precomputed_fallback_used`, `vision_ocr_invoked`.
+
+---
+
+## Data Flow (full pipeline)
+
+```
+1. Officer uploads tender PDF
+        │
+        ▼
+2. criteria_extractor.extract_criteria(pdf)
+   → LLM reads tender text
+   → Returns List[Criterion] with structured rules
+   → Stored in st.session_state["criteria"]
+        │
+        ▼
+3. bidder_processor.process_bidder(bidder_id, files)
+   → For each file: ocr_pipeline.extract_document()
+   → chunker.chunk_bidder()
+   → vectorstore.add_chunks("bidder_chunks", ...)
+        │
+        ▼
+4. evaluator.evaluate(bidder_id, criterion)
+   → bidder_processor.gather_evidence() — semantic search in ChromaDB
+   → LLM evaluates evidence against criterion rule
+   → combined_confidence computed
+   → threshold safety rules applied
+   → Verdict returned + audit logged
+        │
+        ▼
+5. Verdicts stored in st.session_state["verdicts"]
+   → Tab 3: evaluation matrix
+   → Tab 4: needs_review items surfaced for human action
+   → Tab 6: plain-English explanation + Q&A
+   → Tab 5: full audit trail
+```

README.md

@@ -1,3 +1,16 @@
+---
+title: TenderIQ
+emoji: ⚖️
+colorFrom: blue
+colorTo: indigo
+sdk: streamlit
+sdk_version: 1.39.0
+app_file: app.py
+pinned: true
+license: agpl-3.0
+short_description: Explainable AI for Government Tender Evaluation (CRPF Hackathon)
+---
+
 # TenderIQ — Explainable AI for Tender Evaluation
 
 AI-powered eligibility evaluation of bidders against government tender criteria, built for the **CRPF Hackathon, Theme 3**.

app.py

@@ -2,6 +2,7 @@ import shutil
 
 import streamlit as st
 
+from ui.styles import CSS
 from ui.tab_overview import render as render_overview
 from ui.tab_tender import render as render_tender
 from ui.tab_bidders import render as render_bidders
@@ -15,6 +16,8 @@ st.set_page_config(
     layout="wide",
 )
 
+st.markdown(CSS, unsafe_allow_html=True)
+
 
 def _probe_llm() -> str:
     """Probe once per session; returns 'green', 'amber', or 'red'."""
@@ -36,7 +39,6 @@ def _probe_llm() -> str:
 
 
 def _reset_demo() -> None:
-    """Clear session, audit DB, ChromaDB, and OCR cache for a clean demo run."""
     from core import audit
     from core.config import CHROMA_DIR, OCR_CACHE_DIR
     audit.clear()
@@ -49,64 +51,90 @@ def _reset_demo() -> None:
 
 # ── Sidebar ──────────────────────────────────────────────────────────────────
 with st.sidebar:
-    st.markdown("## ⚖️ TenderIQ")
-    st.caption("Explainable AI for Tender Evaluation")
+    st.markdown(
+        """<div style="padding:12px 4px 8px;text-align:center;">
+        <div style="font-size:2.4rem;line-height:1;">⚖️</div>
+        <div style="font-size:1.3rem;font-weight:800;color:#F1F5F9;
+                    letter-spacing:-0.01em;margin-top:6px;">TenderIQ</div>
+        <div style="font-size:0.72rem;color:#94A3B8;margin-top:3px;
+                    text-transform:uppercase;letter-spacing:0.08em;">
+            AI Tender Evaluation</div>
+        </div>""",
+        unsafe_allow_html=True,
+    )
     st.divider()
 
     status = _probe_llm()
     if status == "green":
-        st.markdown("🟢 **DeepSeek:** connected")
+        st.markdown(
+            '<div style="display:flex;align-items:center;gap:8px;padding:6px 0;">'
+            '<div style="width:10px;height:10px;border-radius:50%;background:#22C55E;'
+            'box-shadow:0 0 6px #22C55E;flex-shrink:0;"></div>'
+            '<span style="font-size:0.85rem;font-weight:600;">DeepSeek Connected</span></div>',
+            unsafe_allow_html=True,
+        )
     elif status == "amber":
-        st.markdown("🟡 **DeepSeek:** pre-computed mode")
-        st.warning("⚠ Pre-computed results active.")
+        st.markdown(
+            '<div style="display:flex;align-items:center;gap:8px;padding:6px 0;">'
+            '<div style="width:10px;height:10px;border-radius:50%;background:#F59E0B;'
+            'box-shadow:0 0 6px #F59E0B;flex-shrink:0;"></div>'
+            '<span style="font-size:0.85rem;font-weight:600;">Pre-computed Mode</span></div>',
+            unsafe_allow_html=True,
+        )
+        st.warning("⚠ Showing pre-computed results.")
     else:
-        st.markdown("🔴 **DeepSeek:** not connected")
+        st.markdown(
+            '<div style="display:flex;align-items:center;gap:8px;padding:6px 0;">'
+            '<div style="width:10px;height:10px;border-radius:50%;background:#EF4444;'
+            'box-shadow:0 0 6px #EF4444;flex-shrink:0;"></div>'
+            '<span style="font-size:0.85rem;font-weight:600;">No API Key</span></div>',
+            unsafe_allow_html=True,
+        )
         st.caption("Using pre-computed fallback data.")
 
     st.divider()
 
-    if st.button("Reset Session", use_container_width=True):
+    if st.button("↺  Reset Session", use_container_width=True):
         for key in list(st.session_state.keys()):
             del st.session_state[key]
         st.rerun()
 
-    if st.button("🗑 Reset for Demo", use_container_width=True, type="secondary"):
+    if st.button("🗑  Reset for Demo", use_container_width=True, type="secondary"):
         st.session_state["confirm_demo_reset"] = True
 
     if st.session_state.get("confirm_demo_reset"):
-        st.warning("Clears audit log, vector index, OCR cache, and session. Sure?")
-        col1, col2 = st.columns(2)
-        if col1.button("Yes, reset", type="primary", use_container_width=True):
+        st.warning("Clears audit log, vector index, OCR cache, and session.")
+        c1, c2 = st.columns(2)
+        if c1.button("Yes, reset", type="primary", use_container_width=True):
             _reset_demo()
             st.rerun()
-        if col2.button("Cancel", use_container_width=True):
+        if c2.button("Cancel", use_container_width=True):
             st.session_state.pop("confirm_demo_reset", None)
             st.rerun()
 
+    st.divider()
+    st.caption("CRPF Hackathon · Theme 3\nExplainable AI for Government Procurement")
+
+
 # ── Tabs ─────────────────────────────────────────────────────────────────────
 tab1, tab2, tab3, tab4, tab5, tab6 = st.tabs([
-    "Overview",
-    "Tender Analysis",
-    "Bidder Evaluation",
-    "Human Review",
-    "Audit Log",
-    "Interpretability",
+    "🏠  Overview",
+    "📄  Tender Analysis",
+    "⚖️  Bidder Evaluation",
+    "👤  Human Review",
+    "📋  Audit Log",
+    "🔍  Interpretability",
 ])
 
 with tab1:
     render_overview()
-
 with tab2:
     render_tender()
-
 with tab3:
     render_bidders()
-
 with tab4:
     render_review()
-
 with tab5:
     render_audit()
-
 with tab6:
     render_interpretability()

deck/TenderIQ_Pitch.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b0b09f58d390bbd8e074811a9ddef8bd64489db204f0278041f97658e3a29c80
+size 18040

scripts/generate_deck.py

@@ -0,0 +1,435 @@
+"""Generate TenderIQ_Pitch.pdf — 8-slide pitch deck using reportlab."""
+
+import sys
+from pathlib import Path
+
+BASE_DIR = Path(__file__).resolve().parent.parent
+sys.path.insert(0, str(BASE_DIR))
+
+from reportlab.lib import colors
+from reportlab.lib.pagesizes import A4
+from reportlab.lib.units import cm, mm
+from reportlab.pdfgen.canvas import Canvas
+
+W, H = A4
+NAVY   = colors.HexColor("#0D1B2A")
+BLUE   = colors.HexColor("#2563EB")
+LBLUE  = colors.HexColor("#DBEAFE")
+GOLD   = colors.HexColor("#F0A500")
+WHITE  = colors.white
+GREY   = colors.HexColor("#64748B")
+LGREY  = colors.HexColor("#F1F5F9")
+GREEN  = colors.HexColor("#059669")
+RED    = colors.HexColor("#DC2626")
+AMBER  = colors.HexColor("#D97706")
+BORD   = colors.HexColor("#E2E8F0")
+
+
+def _header_bar(c: Canvas, title: str, subtitle: str = "") -> None:
+    c.setFillColor(NAVY)
+    c.rect(0, H - 2.8*cm, W, 2.8*cm, fill=1, stroke=0)
+    c.setFillColor(GOLD)
+    c.rect(0, H - 2.85*cm, W, 0.18*cm, fill=1, stroke=0)
+    c.setFillColor(WHITE)
+    c.setFont("Helvetica-Bold", 18)
+    c.drawString(1.8*cm, H - 1.7*cm, title)
+    if subtitle:
+        c.setFont("Helvetica", 10)
+        c.setFillColor(colors.HexColor("#94A3B8"))
+        c.drawString(1.8*cm, H - 2.3*cm, subtitle)
+
+
+def _footer(c: Canvas, page: int, total: int = 8) -> None:
+    c.setFillColor(LGREY)
+    c.rect(0, 0, W, 1.0*cm, fill=1, stroke=0)
+    c.setFillColor(GREY)
+    c.setFont("Helvetica", 8)
+    c.drawString(1.8*cm, 0.35*cm, "TenderIQ  ·  CRPF Hackathon Theme 3  ·  Explainable AI for Government Procurement")
+    c.drawRightString(W - 1.8*cm, 0.35*cm, f"{page} / {total}")
+
+
+def _bullet(c: Canvas, x: float, y: float, text: str,
+            size: int = 10, indent: float = 0.5*cm) -> float:
+    c.setFillColor(BLUE)
+    c.circle(x + 0.15*cm, y + 0.3*cm, 0.12*cm, fill=1, stroke=0)
+    c.setFillColor(NAVY)
+    c.setFont("Helvetica", size)
+    lines = _wrap(text, 85 - int(indent / mm))
+    for i, line in enumerate(lines):
+        c.drawString(x + indent, y - i * (size + 3) * 0.035 * cm * 28.35 / 10, line)
+    return y - len(lines) * (size + 4) * 0.035 * cm * 28.35 / 10
+
+
+def _wrap(text: str, width: int) -> list[str]:
+    words = text.split()
+    lines, cur = [], ""
+    for w in words:
+        if len(cur) + len(w) + 1 <= width:
+            cur = (cur + " " + w).strip()
+        else:
+            if cur:
+                lines.append(cur)
+            cur = w
+    if cur:
+        lines.append(cur)
+    return lines or [""]
+
+
+def _card(c: Canvas, x: float, y: float, w: float, h: float,
+          title: str, body: str, accent: colors.Color = BLUE) -> None:
+    c.setFillColor(WHITE)
+    c.setStrokeColor(BORD)
+    c.roundRect(x, y, w, h, 0.3*cm, fill=1, stroke=1)
+    c.setFillColor(accent)
+    c.roundRect(x, y + h - 0.35*cm, w, 0.35*cm, 0.3*cm, fill=1, stroke=0)
+    c.rect(x, y + h - 0.35*cm, w, 0.2*cm, fill=1, stroke=0)
+    c.setFillColor(WHITE)
+    c.setFont("Helvetica-Bold", 9)
+    c.drawString(x + 0.3*cm, y + h - 0.25*cm, title)
+    c.setFillColor(GREY)
+    c.setFont("Helvetica", 8.5)
+    lines = _wrap(body, int(w / (0.22*cm)))
+    for i, line in enumerate(lines[:5]):
+        c.drawString(x + 0.3*cm, y + h - 0.75*cm - i * 0.45*cm, line)
+
+
+def slide_1_title(c: Canvas) -> None:
+    c.setFillColor(NAVY)
+    c.rect(0, 0, W, H, fill=1, stroke=0)
+    c.setFillColor(BLUE)
+    c.rect(0, 0, W, 0.5*cm, fill=1, stroke=0)
+    c.setFillColor(GOLD)
+    c.rect(0, 0.5*cm, W, 0.12*cm, fill=1, stroke=0)
+
+    c.setFillColor(WHITE)
+    c.setFont("Helvetica", 40)
+    c.drawCentredString(W / 2, H - 6*cm, "⚖️")
+    c.setFont("Helvetica-Bold", 36)
+    c.drawCentredString(W / 2, H - 8*cm, "TenderIQ")
+    c.setFont("Helvetica", 15)
+    c.setFillColor(colors.HexColor("#CBD5E1"))
+    c.drawCentredString(W / 2, H - 9.2*cm,
+                        "Explainable AI for Government Tender Evaluation")
+
+    c.setFillColor(GOLD)
+    c.roundRect(W/2 - 5*cm, H - 11.5*cm, 10*cm, 1.1*cm, 0.3*cm, fill=1, stroke=0)
+    c.setFillColor(NAVY)
+    c.setFont("Helvetica-Bold", 11)
+    c.drawCentredString(W / 2, H - 11.0*cm, "CRPF Hackathon  ·  Theme 3")
+
+    c.setFillColor(colors.HexColor("#64748B"))
+    c.setFont("Helvetica", 9)
+    c.drawCentredString(W / 2, H - 13.5*cm,
+                        "Central Reserve Police Force  ·  Ministry of Home Affairs")
+    c.drawCentredString(W / 2, H - 14.1*cm,
+                        "AI-Based Tender Evaluation and Eligibility Analysis")
+
+    _footer(c, 1)
+
+
+def slide_2_problem(c: Canvas) -> None:
+    _header_bar(c, "The Problem", "Manual tender evaluation is slow, inconsistent, and opaque")
+    _footer(c, 2)
+
+    y = H - 4.0*cm
+    c.setFont("Helvetica-Bold", 11)
+    c.setFillColor(NAVY)
+    c.drawString(1.8*cm, y, "Government procurement officers today must:")
+    y -= 0.6*cm
+
+    problems = [
+        "Manually read hundreds of pages of tender documents and bidder submissions",
+        "Identify eligibility criteria buried in legal language across multiple sections",
+        "Cross-check financial statements, certificates, and project records for each bidder",
+        "Handle scanned documents, photographs, and mixed-format submissions",
+        "Reach consistent decisions — yet two evaluators routinely disagree on the same bid",
+        "Produce an auditable trail for every decision, under compliance and RTI pressure",
+    ]
+    for p in problems:
+        y = _bullet(c, 1.8*cm, y, p)
+        y -= 0.25*cm
+
+    y -= 0.3*cm
+    c.setFillColor(LBLUE)
+    c.roundRect(1.8*cm, y - 1.6*cm, W - 3.6*cm, 1.6*cm, 0.3*cm, fill=1, stroke=0)
+    c.setFillColor(BLUE)
+    c.setFont("Helvetica-Bold", 11)
+    c.drawCentredString(W / 2, y - 0.7*cm,
+                        "For one tender, a committee may spend 3–5 days.")
+    c.setFont("Helvetica", 10)
+    c.setFillColor(GREY)
+    c.drawCentredString(W / 2, y - 1.15*cm,
+                        "TenderIQ reduces this to minutes, with full explainability.")
+
+
+def slide_3_solution(c: Canvas) -> None:
+    _header_bar(c, "Our Solution", "TenderIQ automates evaluation while preserving human oversight")
+    _footer(c, 3)
+
+    pillars = [
+        (BLUE,  "📄 Extract",    "DeepSeek LLM reads the tender PDF and structures every eligibility criterion as JSON — category, rule, source clause, query hints."),
+        (GREEN, "🔍 OCR & Index","Three-tier pipeline handles any document: PyMuPDF → Tesseract → Vision LLM. All text indexed into ChromaDB with provenance."),
+        (AMBER, "⚖️ Evaluate",  "Per-criterion vector search + LLM evaluation. Combined confidence score. Safety rule: never silent disqualification."),
+        (RED,   "👤 Review",    "Borderline verdicts surface in a human review queue with full evidence. Every action logged to SQLite for compliance."),
+    ]
+    cw = (W - 3.6*cm) / 2
+    ch = 5.0*cm
+    positions = [
+        (1.8*cm, H - 9.5*cm),
+        (1.8*cm + cw + 0.4*cm, H - 9.5*cm),
+        (1.8*cm, H - 9.5*cm - ch - 0.5*cm),
+        (1.8*cm + cw + 0.4*cm, H - 9.5*cm - ch - 0.5*cm),
+    ]
+    for (px, py), (color, title, body) in zip(positions, pillars):
+        _card(c, px, py, cw, ch, title, body, color)
+
+
+def slide_4_architecture(c: Canvas) -> None:
+    _header_bar(c, "Architecture", "Single-process Streamlit app — no separate services")
+    _footer(c, 4)
+
+    boxes = [
+        (1.8*cm,  H - 5.5*cm, 5.0*cm, 1.2*cm, "Tender PDF",       LBLUE, BLUE),
+        (8.5*cm,  H - 5.5*cm, 5.5*cm, 1.2*cm, "Criteria (JSON)",  LBLUE, BLUE),
+        (15.5*cm, H - 5.5*cm, 4.5*cm, 1.2*cm, "ChromaDB Index",   LGREY, GREY),
+        (1.8*cm,  H - 9.0*cm, 5.0*cm, 1.2*cm, "Bidder Docs",      LGREY, GREY),
+        (8.5*cm,  H - 9.0*cm, 5.5*cm, 1.2*cm, "OCR Pipeline ×3",  colors.HexColor("#FDF4FF"), colors.HexColor("#7E22CE")),
+        (15.5*cm, H - 9.0*cm, 4.5*cm, 1.2*cm, "Verdicts",         colors.HexColor("#F0FDF4"), GREEN),
+        (5.5*cm,  H - 13.0*cm, 10*cm, 1.2*cm, "SQLite Audit Log",  colors.HexColor("#FFFBEB"), AMBER),
+    ]
+    for bx, by, bw, bh, label, fill, stroke in boxes:
+        c.setFillColor(fill)
+        c.setStrokeColor(stroke)
+        c.roundRect(bx, by, bw, bh, 0.25*cm, fill=1, stroke=1)
+        c.setFillColor(stroke)
+        c.setFont("Helvetica-Bold", 9)
+        c.drawCentredString(bx + bw / 2, by + 0.4*cm, label)
+
+    arrows = [
+        (6.8*cm, H - 4.95*cm, 8.5*cm, H - 4.95*cm),
+        (8.5*cm + 5.5*cm, H - 4.95*cm, 15.5*cm, H - 4.95*cm),
+        (1.8*cm + 5.0*cm, H - 8.45*cm, 8.5*cm, H - 8.45*cm),
+        (8.5*cm + 5.5*cm, H - 8.45*cm, 15.5*cm, H - 8.45*cm),
+        (15.5*cm + 2.25*cm, H - 9.0*cm, 15.5*cm + 2.25*cm, H - 5.5*cm - 1.2*cm),
+        (W / 2, H - 9.0*cm - 0, W / 2, H - 13.0*cm + 1.2*cm),
+    ]
+    c.setStrokeColor(GREY)
+    c.setLineWidth(1)
+    for x1, y1, x2, y2 in arrows:
+        c.line(x1, y1, x2, y2)
+
+    c.setFont("Helvetica", 8.5)
+    c.setFillColor(GREY)
+    c.drawCentredString(W / 2, H - 14.5*cm,
+                        "DeepSeek API  ·  ChromaDB (embedded)  ·  SQLite  ·  No external services")
+
+
+def slide_5_ocr(c: Canvas) -> None:
+    _header_bar(c, "Three-Tier OCR Pipeline",
+                "Handles typed PDFs, scanned documents, and photographs")
+    _footer(c, 5)
+
+    tiers = [
+        (BLUE,  "Tier 1 — PyMuPDF",
+         "Cost: free, instant\nTrigger: document is a typed/digital PDF\nConfidence: 1.0 (lossless)\nOutput: exact text with page numbers"),
+        (colors.HexColor("#7E22CE"), "Tier 2 — Tesseract OCR",
+         "Cost: free, fast\nTrigger: scanned PDF or image file\nConfidence: mean of per-word scores\nOutput: extracted text (quality varies)"),
+        (AMBER, "Tier 3 — DeepSeek Vision LLM",
+         "Cost: API call, slower\nTrigger: Tesseract confidence < 65%\nConfidence: 0.95\nOutput: faithfully transcribed text\nAudit: vision_ocr_invoked logged"),
+    ]
+    tw = (W - 4.0*cm) / 3
+    for i, (color, title, body) in enumerate(tiers):
+        x = 1.8*cm + i * (tw + 0.3*cm)
+        y = H - 9.0*cm
+        c.setFillColor(color)
+        c.roundRect(x, y, tw, 5.5*cm, 0.3*cm, fill=1, stroke=0)
+        c.setFillColor(WHITE)
+        c.setFont("Helvetica-Bold", 10)
+        c.drawCentredString(x + tw / 2, y + 5.0*cm, title)
+        c.setFont("Helvetica", 9)
+        for j, line in enumerate(body.split("\n")):
+            c.drawString(x + 0.4*cm, y + 4.2*cm - j * 0.5*cm, line)
+
+    y = H - 11.0*cm
+    c.setFillColor(LGREY)
+    c.roundRect(1.8*cm, y - 1.8*cm, W - 3.6*cm, 1.8*cm, 0.3*cm, fill=1, stroke=0)
+    c.setFillColor(NAVY)
+    c.setFont("Helvetica-Bold", 10)
+    c.drawCentredString(W / 2, y - 0.65*cm, "Demo: Bidder C submits a blurry, rotated CA certificate scan")
+    c.setFont("Helvetica", 9)
+    c.setFillColor(GREY)
+    c.drawCentredString(W / 2, y - 1.2*cm,
+                        "Tesseract confidence ~55% → Vision LLM transcribes correctly → combined confidence 0.58 → needs_review")
+
+
+def slide_6_explainability(c: Canvas) -> None:
+    _header_bar(c, "Explainability & Compliance",
+                "Every verdict is traceable to a document, page, and model decision")
+    _footer(c, 6)
+
+    features = [
+        ("Criterion-level verdicts",
+         "Each (bidder × criterion) pair has an independent verdict with extracted value, source document, page number, OCR tier, LLM confidence, and plain-English reason."),
+        ("Never silent disqualification",
+         "The safety threshold rule: if combined confidence is 0.55–0.80 and the LLM says not_eligible, the verdict is downgraded to needs_review and surfaced for human review."),
+        ("Full audit trail",
+         "Every action is logged to SQLite: criteria_extracted, bidder_processed, criterion_evaluated, human_review_action, vision_ocr_invoked, precomputed_fallback_used."),
+        ("Interpretability tab",
+         "Plain-English explanation of each verdict with inline PDF page previews. LLM-powered Q&A lets officers ask specific questions with source citations."),
+        ("Human review queue",
+         "Flagged verdicts show the evidence snippet, extracted value, source page, and OCR tier badge. Officers Approve / Edit & Approve / Reject with audit logging."),
+        ("Pre-computed fallback",
+         "If the API is unavailable, pre-computed JSON is served transparently. The sidebar shows an amber dot and a banner. No silent failures."),
+    ]
+    col_w = (W - 4.0*cm) / 2
+    for i, (title, body) in enumerate(features):
+        col = i % 2
+        row = i // 2
+        x = 1.8*cm + col * (col_w + 0.4*cm)
+        y = H - 4.5*cm - row * 2.8*cm
+        c.setFillColor(WHITE)
+        c.setStrokeColor(BORD)
+        c.roundRect(x, y - 2.0*cm, col_w, 2.0*cm, 0.25*cm, fill=1, stroke=1)
+        c.setFillColor(BLUE)
+        c.setFont("Helvetica-Bold", 9)
+        c.drawString(x + 0.3*cm, y - 0.45*cm, title)
+        c.setFillColor(GREY)
+        c.setFont("Helvetica", 8)
+        lines = _wrap(body, int(col_w / (0.22*cm)))
+        for j, line in enumerate(lines[:3]):
+            c.drawString(x + 0.3*cm, y - 0.9*cm - j * 0.38*cm, line)
+
+
+def slide_7_demo(c: Canvas) -> None:
+    _header_bar(c, "Demo: Three Test Scenarios",
+                "Mock CRPF tender with 5 criteria evaluated against 3 realistic bidders")
+    _footer(c, 7)
+
+    scenarios = [
+        (GREEN, "✅ Bidder A — Eligible",
+         "Apex Constructions Pvt. Ltd.",
+         [
+             "C1 Turnover: INR 6.37 Cr avg — exceeds 5 Cr threshold",
+             "C2 Projects: 5 completed including CRPF barracks (2024)",
+             "C3 GST: GSTIN 27AABCA1234F1Z5, Active",
+             "C4 ISO 9001:2015: Valid through June 2027",
+             "C5 Paramilitary: CRPF Camp Pune project on record",
+         ]),
+        (RED, "❌ Bidder B — Not Eligible",
+         "BuildRight Enterprises",
+         [
+             "C1 Turnover: INR 1.5 Cr avg — BELOW 5 Cr threshold",
+             "C2 Projects: 4 completed — passes",
+             "C3 GST: GSTIN 29AABCB5678G1Z3, Active",
+             "C4 ISO 9001:2015: Valid through August 2027",
+             "C5 Paramilitary: No relevant experience",
+         ]),
+        (AMBER, "⚠️ Bidder C — Needs Review",
+         "Shree Constructions & Services",
+         [
+             "C1 Turnover: Scanned cert → Tesseract 55% → Vision LLM",
+             "    INR 5.4 Cr found, but borderline — human review required",
+             "C2 Projects: Exactly 3 — borderline meets threshold",
+             "C3 GST: GSTIN 24AABCC9012H1Z1, Active",
+             "C4 ISO 9001:2015: Valid through September 2027",
+         ]),
+    ]
+    cw = (W - 4.0*cm) / 3
+    for i, (color, title, company, bullets) in enumerate(scenarios):
+        x = 1.8*cm + i * (cw + 0.3*cm)
+        y_top = H - 3.8*cm
+
+        c.setFillColor(color)
+        c.roundRect(x, y_top - 0.9*cm, cw, 0.9*cm, 0.25*cm, fill=1, stroke=0)
+        c.setFillColor(WHITE)
+        c.setFont("Helvetica-Bold", 9)
+        c.drawCentredString(x + cw / 2, y_top - 0.55*cm, title)
+
+        c.setFillColor(WHITE)
+        c.setStrokeColor(BORD)
+        c.roundRect(x, y_top - 8.5*cm, cw, 7.6*cm, 0.25*cm, fill=1, stroke=1)
+        c.rect(x, y_top - 0.9*cm, cw, 0.2*cm, fill=1, stroke=0)
+
+        c.setFillColor(GREY)
+        c.setFont("Helvetica-Oblique", 8)
+        c.drawString(x + 0.3*cm, y_top - 1.35*cm, company)
+
+        c.setFont("Helvetica", 8)
+        c.setFillColor(NAVY)
+        for j, b in enumerate(bullets):
+            c.drawString(x + 0.3*cm, y_top - 2.0*cm - j * 0.5*cm, b)
+
+
+def slide_8_stack(c: Canvas) -> None:
+    _header_bar(c, "Technology Stack & Impact",
+                "Built for the hackathon — deployable to Streamlit Cloud or HuggingFace Spaces in minutes")
+    _footer(c, 8)
+
+    stack = [
+        ("UI & Orchestration", "Streamlit 1.39", "Single-process app, tabs, session state"),
+        ("LLM",               "DeepSeek API",   "chat_json + chat_vision (OpenAI-compatible)"),
+        ("OCR Tier 1",        "PyMuPDF 1.24",   "Lossless text extraction from digital PDFs"),
+        ("OCR Tier 2",        "Tesseract",      "Open-source OCR for scanned documents"),
+        ("OCR Tier 3",        "DeepSeek Vision","Multimodal LLM for low-confidence scans"),
+        ("Vector Store",      "ChromaDB 0.5",   "Embedded, file-backed, all-MiniLM-L6-v2"),
+        ("Schemas",           "Pydantic v2",    "Strict validation of all LLM outputs"),
+        ("Audit Log",         "SQLite",         "Append-only, exportable as CSV"),
+    ]
+    c.setFillColor(NAVY)
+    c.setFont("Helvetica-Bold", 9)
+    col_x = [1.8*cm, 6.5*cm, 11.5*cm]
+    for x, lbl in zip(col_x, ["Component", "Technology", "Role"]):
+        c.drawString(x, H - 4.2*cm, lbl)
+    c.setStrokeColor(BORD)
+    c.line(1.8*cm, H - 4.4*cm, W - 1.8*cm, H - 4.4*cm)
+
+    for i, (comp, tech, role) in enumerate(stack):
+        y = H - 4.9*cm - i * 0.6*cm
+        if i % 2 == 0:
+            c.setFillColor(LGREY)
+            c.rect(1.8*cm, y - 0.1*cm, W - 3.6*cm, 0.55*cm, fill=1, stroke=0)
+        c.setFillColor(NAVY);  c.setFont("Helvetica-Bold", 8.5); c.drawString(1.8*cm + 0.2*cm, y + 0.2*cm, comp)
+        c.setFillColor(BLUE);  c.setFont("Helvetica", 8.5);      c.drawString(6.5*cm + 0.2*cm, y + 0.2*cm, tech)
+        c.setFillColor(GREY);  c.setFont("Helvetica", 8.5);      c.drawString(11.5*cm + 0.2*cm, y + 0.2*cm, role)
+
+    y_impact = H - 10.5*cm
+    c.setFillColor(NAVY)
+    c.roundRect(1.8*cm, y_impact - 2.8*cm, W - 3.6*cm, 2.8*cm, 0.3*cm, fill=1, stroke=0)
+    c.setFillColor(GOLD)
+    c.setFont("Helvetica-Bold", 11)
+    c.drawCentredString(W / 2, y_impact - 0.7*cm, "Business Impact")
+    impacts = [
+        "⏱  Days of manual evaluation → minutes of automated processing",
+        "📋  Criterion-level audit trail satisfies RTI and compliance requirements",
+        "🔍  Every verdict traceable to a document, page, OCR tier, and model version",
+    ]
+    c.setFont("Helvetica", 9.5)
+    c.setFillColor(colors.HexColor("#CBD5E1"))
+    for j, imp in enumerate(impacts):
+        c.drawString(2.5*cm, y_impact - 1.35*cm - j * 0.5*cm, imp)
+
+
+def main() -> None:
+    out = BASE_DIR / "deck" / "TenderIQ_Pitch.pdf"
+    out.parent.mkdir(parents=True, exist_ok=True)
+
+    c = Canvas(str(out), pagesize=A4)
+    slides = [
+        slide_1_title,
+        slide_2_problem,
+        slide_3_solution,
+        slide_4_architecture,
+        slide_5_ocr,
+        slide_6_explainability,
+        slide_7_demo,
+        slide_8_stack,
+    ]
+    for fn in slides:
+        fn(c)
+        c.showPage()
+    c.save()
+    print(f"Deck saved: {out}  ({len(slides)} slides)")
+
+
+if __name__ == "__main__":
+    main()

ui/components.py

@@ -2,32 +2,64 @@ import streamlit as st
 
 
 def verdict_pill(verdict: str) -> str:
-    if verdict == "eligible":
-        return ":green[✅ Eligible]"
-    elif verdict == "not_eligible":
-        return ":red[❌ Not Eligible]"
-    else:
-        return ":orange[⚠ Needs Review]"
+    cfg = {
+        "eligible":     ("tiq-eligible",  "✅ Eligible"),
+        "not_eligible": ("tiq-not-elig",  "❌ Not Eligible"),
+        "needs_review": ("tiq-review",    "⚠️ Needs Review"),
+    }
+    cls, label = cfg.get(verdict, ("tiq-review", verdict))
+    return f'<span class="tiq-badge {cls}">{label}</span>'
 
 
-def confidence_bar(value: float, label: str = "Confidence") -> None:
-    st.progress(min(max(value, 0.0), 1.0), text=f"{label}: {value:.0%}")
+def category_badge(category: str) -> str:
+    cfg = {
+        "financial":  ("tiq-cat-fin",  "💰 Financial"),
+        "technical":  ("tiq-cat-tech", "🔧 Technical"),
+        "compliance": ("tiq-cat-comp", "📋 Compliance"),
+    }
+    cls, label = cfg.get(category, ("tiq-cat-comp", category))
+    return f'<span class="tiq-badge {cls}">{label}</span>'
 
 
 def ocr_tier_badge(source_type: str) -> str:
-    icons = {
-        "text_pdf": "📄 text_pdf",
-        "tesseract": "🔍 tesseract",
-        "vision_llm": "👁 vision_llm",
+    cfg = {
+        "text_pdf":   ("tiq-ocr-text",   "📄 Typed PDF"),
+        "tesseract":  ("tiq-ocr-tess",   "🔍 Tesseract"),
+        "vision_llm": ("tiq-ocr-vision", "👁 Vision LLM"),
     }
-    return icons.get(source_type, f"❓ {source_type}")
+    cls, label = cfg.get(source_type, ("tiq-ocr-text", source_type))
+    return f'<span class="tiq-badge {cls}">{label}</span>'
 
 
-def category_badge(category: str) -> str:
-    if category == "financial":
-        return ":blue[financial]"
-    elif category == "technical":
-        return ":green[technical]"
-    elif category == "compliance":
-        return ":orange[compliance]"
-    return category
+def mandatory_badge(mandatory: bool) -> str:
+    if mandatory:
+        return '<span class="tiq-badge tiq-mand">🔴 Mandatory</span>'
+    return '<span class="tiq-badge tiq-optional">🟡 Optional</span>'
+
+
+def confidence_bar(value: float, label: str = "Confidence") -> None:
+    pct = min(max(value, 0.0), 1.0)
+    color = "#22C55E" if pct >= 0.8 else "#F59E0B" if pct >= 0.55 else "#EF4444"
+    st.markdown(
+        f"""<div style="margin:4px 0 8px;">
+        <div style="display:flex;justify-content:space-between;
+                    font-size:0.75rem;color:#64748B;margin-bottom:3px;">
+            <span>{label}</span><span style="font-weight:600;color:{color};">{pct:.0%}</span>
+        </div>
+        <div style="background:#E2E8F0;border-radius:6px;height:7px;overflow:hidden;">
+            <div style="width:{pct*100:.1f}%;background:{color};
+                        height:100%;border-radius:6px;
+                        transition:width 0.4s ease;"></div>
+        </div></div>""",
+        unsafe_allow_html=True,
+    )
+
+
+def section_header(title: str, subtitle: str = "") -> None:
+    st.markdown(
+        f'<div class="tiq-section-header">'
+        f'<div style="font-size:1.1rem;font-weight:700;color:#0D1B2A;">{title}</div>'
+        + (f'<div style="font-size:0.82rem;color:#64748B;margin-top:2px;">{subtitle}</div>' if subtitle else "")
+        + "</div>",
+        unsafe_allow_html=True,
+    )

ui/styles.py

@@ -0,0 +1,257 @@
+CSS = """
+<style>
+/* ================================================================
+   TenderIQ — Professional Theme
+   ================================================================ */
+
+/* ── Global ──────────────────────────────────────────────────── */
+.main .block-container {
+    padding-top: 1.5rem !important;
+    padding-bottom: 2rem !important;
+    max-width: 1200px;
+}
+h1 { font-weight: 800 !important; color: #0D1B2A !important; letter-spacing: -0.02em; }
+h2 { font-weight: 700 !important; color: #0D1B2A !important; }
+h3 { font-weight: 600 !important; color: #0D1B2A !important; }
+h4 { font-weight: 600 !important; color: #1E3A5F !important; }
+p  { color: #374151; line-height: 1.7; }
+code {
+    background: #EFF6FF !important;
+    color: #1E40AF !important;
+    padding: 2px 6px !important;
+    border-radius: 4px !important;
+    font-size: 0.85em !important;
+    border: 1px solid #DBEAFE;
+}
+hr { border-color: #E2E8F0 !important; margin: 1.25rem 0 !important; }
+
+/* ── Sidebar ─────────────────────────────────────────────────── */
+[data-testid="stSidebar"] {
+    background: linear-gradient(175deg, #0D1B2A 0%, #1E3A5F 100%) !important;
+    border-right: 1px solid #1E3A5F;
+}
+[data-testid="stSidebar"] p,
+[data-testid="stSidebar"] span,
+[data-testid="stSidebar"] label,
+[data-testid="stSidebar"] div {
+    color: #CBD5E1 !important;
+}
+[data-testid="stSidebar"] h1,
+[data-testid="stSidebar"] h2,
+[data-testid="stSidebar"] h3,
+[data-testid="stSidebar"] strong {
+    color: #F1F5F9 !important;
+}
+[data-testid="stSidebar"] .stButton > button {
+    background: rgba(255,255,255,0.07) !important;
+    border: 1px solid rgba(255,255,255,0.15) !important;
+    color: #E2E8F0 !important;
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+    transition: all 0.2s ease !important;
+    width: 100%;
+}
+[data-testid="stSidebar"] .stButton > button:hover {
+    background: rgba(255,255,255,0.14) !important;
+    border-color: rgba(255,255,255,0.3) !important;
+    color: #FFFFFF !important;
+}
+[data-testid="stSidebar"] [data-testid="stDivider"] { border-color: rgba(255,255,255,0.12) !important; }
+[data-testid="stSidebar"] .stAlert {
+    background: rgba(245,158,11,0.15) !important;
+    border: 1px solid rgba(245,158,11,0.3) !important;
+    border-radius: 8px !important;
+}
+[data-testid="stSidebar"] [data-testid="stCaptionContainer"] p { color: #94A3B8 !important; }
+
+/* ── Tabs ────────────────────────────────────────────────────── */
+.stTabs [data-baseweb="tab-list"] {
+    background: #F1F5F9 !important;
+    border-radius: 12px !important;
+    padding: 5px !important;
+    gap: 2px !important;
+    border: 1px solid #E2E8F0;
+}
+.stTabs [data-baseweb="tab"] {
+    border-radius: 8px !important;
+    padding: 8px 18px !important;
+    font-weight: 500 !important;
+    font-size: 0.875rem !important;
+    color: #64748B !important;
+    border: none !important;
+    background: transparent !important;
+    transition: all 0.15s ease !important;
+}
+.stTabs [data-baseweb="tab"]:hover { color: #1E3A5F !important; background: rgba(255,255,255,0.6) !important; }
+.stTabs [aria-selected="true"] {
+    background: #FFFFFF !important;
+    color: #0D1B2A !important;
+    box-shadow: 0 1px 6px rgba(0,0,0,0.1) !important;
+    font-weight: 600 !important;
+}
+.stTabs [data-baseweb="tab-highlight"] { display: none !important; }
+.stTabs [data-baseweb="tab-border"] { display: none !important; }
+
+/* ── Buttons ─────────────────────────────────────────────────── */
+.stButton > button {
+    border-radius: 8px !important;
+    font-weight: 500 !important;
+    font-size: 0.875rem !important;
+    transition: all 0.2s ease !important;
+    border: 1px solid #E2E8F0 !important;
+}
+.stButton > button[kind="primary"] {
+    background: linear-gradient(135deg, #1E3A5F 0%, #2563EB 100%) !important;
+    color: #FFFFFF !important;
+    border: none !important;
+    box-shadow: 0 2px 8px rgba(37,99,235,0.3) !important;
+}
+.stButton > button[kind="primary"]:hover {
+    box-shadow: 0 4px 16px rgba(37,99,235,0.45) !important;
+    transform: translateY(-1px) !important;
+}
+.stButton > button[kind="secondary"] { color: #374151 !important; }
+.stButton > button[kind="secondary"]:hover { background: #F1F5F9 !important; }
+
+/* ── Metric cards ────────────────────────────────────────────── */
+[data-testid="metric-container"] {
+    background: #FFFFFF !important;
+    border: 1px solid #E2E8F0 !important;
+    border-radius: 12px !important;
+    padding: 20px !important;
+    box-shadow: 0 1px 4px rgba(0,0,0,0.06) !important;
+    transition: box-shadow 0.2s, transform 0.2s;
+}
+[data-testid="metric-container"]:hover {
+    box-shadow: 0 4px 16px rgba(0,0,0,0.1) !important;
+    transform: translateY(-1px);
+}
+[data-testid="stMetricValue"] { font-size: 2.2rem !important; font-weight: 800 !important; color: #0D1B2A !important; }
+[data-testid="stMetricLabel"] { font-size: 0.75rem !important; font-weight: 600 !important; color: #64748B !important; text-transform: uppercase; letter-spacing: 0.06em; }
+[data-testid="stMetricDelta"] { font-size: 0.8rem !important; }
+
+/* ── Bordered containers (cards) ─────────────────────────────── */
+[data-testid="stVerticalBlockBorderWrapper"] {
+    border-radius: 12px !important;
+    border: 1px solid #E2E8F0 !important;
+    box-shadow: 0 2px 8px rgba(0,0,0,0.05) !important;
+    overflow: hidden;
+    transition: box-shadow 0.2s;
+}
+[data-testid="stVerticalBlockBorderWrapper"]:hover {
+    box-shadow: 0 4px 16px rgba(0,0,0,0.09) !important;
+}
+
+/* ── Expanders ───────────────────────────────────────────────── */
+[data-testid="stExpander"] {
+    border: 1px solid #E2E8F0 !important;
+    border-radius: 10px !important;
+    overflow: hidden !important;
+    margin-bottom: 4px !important;
+}
+[data-testid="stExpander"] summary {
+    font-weight: 500 !important;
+    color: #374151 !important;
+    padding: 10px 14px !important;
+    background: #F8FAFC;
+}
+[data-testid="stExpander"] summary:hover { background: #F1F5F9 !important; }
+
+/* ── Alerts ──────────────────────────────────────────────────── */
+[data-testid="stAlert"] { border-radius: 10px !important; border: none !important; }
+div[data-testid="stAlert"][data-baseweb="notification"][kind="info"] {
+    background: #EFF6FF !important; border-left: 4px solid #3B82F6 !important;
+}
+div[data-testid="stAlert"][data-baseweb="notification"][kind="success"] {
+    background: #F0FDF4 !important; border-left: 4px solid #22C55E !important;
+}
+div[data-testid="stAlert"][data-baseweb="notification"][kind="warning"] {
+    background: #FFFBEB !important; border-left: 4px solid #F59E0B !important;
+}
+div[data-testid="stAlert"][data-baseweb="notification"][kind="error"] {
+    background: #FEF2F2 !important; border-left: 4px solid #EF4444 !important;
+}
+
+/* ── Progress bar ────────────────────────────────────────────── */
+.stProgress > div > div > div { border-radius: 6px !important; }
+.stProgress > div > div > div > div {
+    background: linear-gradient(90deg, #1E3A5F, #2563EB) !important;
+    border-radius: 6px !important;
+}
+
+/* ── Forms (inputs, selects) ─────────────────────────────────── */
+[data-baseweb="input"],
+[data-baseweb="select"],
+[data-baseweb="textarea"] {
+    border-radius: 8px !important;
+    border-color: #E2E8F0 !important;
+}
+[data-baseweb="input"]:focus-within,
+[data-baseweb="select"]:focus-within {
+    border-color: #2563EB !important;
+    box-shadow: 0 0 0 3px rgba(37,99,235,0.1) !important;
+}
+
+/* ── Dataframe ───────────────────────────────────────────────── */
+[data-testid="stDataFrame"] {
+    border-radius: 10px !important;
+    overflow: hidden !important;
+    border: 1px solid #E2E8F0 !important;
+}
+
+/* ── Caption ─────────────────────────────────────────────────── */
+[data-testid="stCaptionContainer"] p { color: #94A3B8 !important; font-size: 0.8rem !important; }
+
+/* ── Spinner ─────────────────────────────────────────────────── */
+.stSpinner > div { border-top-color: #2563EB !important; }
+
+/* ── Hide Streamlit chrome ───────────────────────────────────── */
+#MainMenu { visibility: hidden !important; }
+footer    { visibility: hidden !important; }
+header    { visibility: hidden !important; }
+
+/* ── Verdict badge utility classes ───────────────────────────── */
+.tiq-badge {
+    display: inline-flex; align-items: center; gap: 5px;
+    padding: 4px 12px; border-radius: 20px;
+    font-size: 0.8rem; font-weight: 600; white-space: nowrap;
+}
+.tiq-eligible   { background:#D1FAE5; color:#065F46; border:1px solid #A7F3D0; }
+.tiq-not-elig   { background:#FEE2E2; color:#991B1B; border:1px solid #FECACA; }
+.tiq-review     { background:#FEF3C7; color:#92400E; border:1px solid #FDE68A; }
+.tiq-cat-fin    { background:#DBEAFE; color:#1E40AF; border:1px solid #BFDBFE; }
+.tiq-cat-tech   { background:#DCFCE7; color:#166534; border:1px solid #BBF7D0; }
+.tiq-cat-comp   { background:#FEF3C7; color:#92400E; border:1px solid #FDE68A; }
+.tiq-ocr-text   { background:#F1F5F9; color:#475569; border:1px solid #CBD5E1; }
+.tiq-ocr-tess   { background:#FDF4FF; color:#7E22CE; border:1px solid #E9D5FF; }
+.tiq-ocr-vision { background:#FFF7ED; color:#C2410C; border:1px solid #FED7AA; }
+.tiq-mand       { background:#FEE2E2; color:#991B1B; border:1px solid #FECACA; }
+.tiq-optional   { background:#FFFBEB; color:#92400E; border:1px solid #FDE68A; }
+
+/* ── Hero banner ─────────────────────────────────────────────── */
+.tiq-hero {
+    background: linear-gradient(135deg, #0D1B2A 0%, #1E3A5F 50%, #2563EB 100%);
+    border-radius: 16px; padding: 2.5rem 2rem; margin-bottom: 1.5rem;
+    color: white;
+}
+.tiq-hero h1 { color: #FFFFFF !important; margin: 0; font-size: 2rem; }
+.tiq-hero p  { color: #CBD5E1 !important; margin: 0.5rem 0 0; font-size: 1.05rem; }
+
+/* ── Kpi strip ───────────────────────────────────────────────── */
+.tiq-kpi {
+    background: #FFFFFF; border-radius: 12px; padding: 18px 20px;
+    border: 1px solid #E2E8F0;
+    box-shadow: 0 1px 4px rgba(0,0,0,0.06);
+    text-align: center;
+}
+.tiq-kpi-val { font-size: 2rem; font-weight: 800; color: #0D1B2A; }
+.tiq-kpi-lbl { font-size: 0.72rem; font-weight: 600; color: #64748B;
+               text-transform: uppercase; letter-spacing: 0.07em; margin-top: 2px; }
+
+/* ── Section header ─────────────────────────────────────────── */
+.tiq-section-header {
+    border-left: 4px solid #2563EB; padding-left: 12px;
+    margin: 1.5rem 0 1rem;
+}
+</style>
+"""

ui/tab_bidders.py

@@ -4,12 +4,20 @@ from core import bidder_processor, evaluator
 from core.config import BIDDER_NAMES, DATA_DIR
 from core.fallback import load_criteria
 from core.schemas import Criterion
-from ui.components import category_badge, confidence_bar, ocr_tier_badge, verdict_pill
+from ui.components import (
+    category_badge, confidence_bar, mandatory_badge,
+    ocr_tier_badge, section_header, verdict_pill,
+)
 
 _BIDDER_LABELS = {
-    "bidder_a": "Bidder A — Apex Constructions Pvt. Ltd. (Clearly Eligible)",
-    "bidder_b": "Bidder B — BuildRight Enterprises (Ineligible: Low Turnover)",
-    "bidder_c": "Bidder C — Shree Constructions & Services (Scanned Cert: Needs Review)",
+    "bidder_a": "Apex Constructions Pvt. Ltd.",
+    "bidder_b": "BuildRight Enterprises",
+    "bidder_c": "Shree Constructions & Services",
+}
+_BIDDER_SUBLABELS = {
+    "bidder_a": "Clearly Eligible",
+    "bidder_b": "Ineligible — Turnover Below Threshold",
+    "bidder_c": "Needs Review — Scanned Certificate",
 }
 
 
@@ -21,11 +29,11 @@ def _get_criteria() -> list[Criterion]:
 
 
 def _overall_verdict(verdicts: list[dict], crit_map: dict) -> str:
-    """Only mandatory criteria determine overall eligibility."""
-    mandatory = [v for v in verdicts if crit_map.get(v["criterion_id"], None) and
+    mandatory = [v for v in verdicts
+                 if crit_map.get(v["criterion_id"]) and
                  crit_map[v["criterion_id"]].mandatory]
     if not mandatory:
-        mandatory = verdicts  # fallback if crit_map is missing
+        mandatory = verdicts
     if any(v["verdict"] == "not_eligible" for v in mandatory):
         return "not_eligible"
     if any(v["verdict"] == "needs_review" for v in mandatory):
@@ -35,18 +43,19 @@ def _overall_verdict(verdicts: list[dict], crit_map: dict) -> str:
 
 def render() -> None:
     st.header("Bidder Evaluation")
+    st.caption("Run the full evaluation pipeline or load pre-computed results from the Overview tab.")
 
     selected = st.multiselect(
         "Select bidders to evaluate",
-        options=["bidder_a", "bidder_b", "bidder_c"],
-        default=["bidder_a", "bidder_b", "bidder_c"],
-        format_func=lambda x: _BIDDER_LABELS.get(x, x),
+        options=list(BIDDER_NAMES.keys()),
+        default=list(BIDDER_NAMES.keys()),
+        format_func=lambda x: f"{_BIDDER_LABELS.get(x, x)} — {_BIDDER_SUBLABELS.get(x, '')}",
     )
 
-    if st.button("Run Evaluation", type="primary"):
+    if st.button("▶  Run Evaluation", type="primary"):
         criteria = _get_criteria()
         verdicts_dict: dict = {}
-        progress = st.progress(0, text="Starting evaluation…")
+        progress = st.progress(0, text="Starting…")
         total = len(selected) * len(criteria)
         done = 0
         for bidder_id in selected:
@@ -54,7 +63,7 @@ def render() -> None:
                 f for f in (DATA_DIR / "bidders" / bidder_id).iterdir()
                 if f.suffix.lower() in {".pdf", ".png", ".jpg"}
             )
-            with st.spinner(f"Processing {BIDDER_NAMES.get(bidder_id, bidder_id)} documents…"):
+            with st.spinner(f"Processing {_BIDDER_LABELS.get(bidder_id, bidder_id)}…"):
                 bidder_processor.process_bidder(bidder_id, files)
             verdicts_list = []
             for c in criteria:
@@ -62,17 +71,21 @@ def render() -> None:
                 verdicts_list.append(v.model_dump())
                 done += 1
                 progress.progress(done / total,
-                                  text=f"Evaluated {c.id} for {BIDDER_NAMES.get(bidder_id, bidder_id)}")
+                                  text=f"Evaluated {c.id} · {_BIDDER_LABELS.get(bidder_id, bidder_id)}")
             verdicts_dict[bidder_id] = verdicts_list
         st.session_state["verdicts"] = verdicts_dict
         progress.empty()
-        st.success("Evaluation complete.")
+        st.success("Evaluation complete. Results saved.")
         st.rerun()
 
     verdicts_data = st.session_state.get("verdicts", {})
     criteria = _get_criteria()
     crit_map = {c.id: c for c in criteria}
 
+    if not verdicts_data:
+        st.info("No results yet. Click **Run Evaluation** above, or load the demo from the Overview tab.")
+        return
+
     if st.session_state.get("fallback_active"):
         st.warning("⚠ Live API unavailable — showing pre-computed results.")
 
@@ -81,58 +94,103 @@ def render() -> None:
             continue
         verdicts = verdicts_data[bidder_id]
         overall = _overall_verdict(verdicts, crit_map)
-        overall_pill = verdict_pill(overall)
-        friendly = BIDDER_NAMES.get(bidder_id, bidder_id)
-        mandatory_count = sum(1 for v in verdicts
-                              if crit_map.get(v["criterion_id"]) and
-                              crit_map[v["criterion_id"]].mandatory)
+        op = verdict_pill(overall)
+        friendly = _BIDDER_LABELS.get(bidder_id, bidder_id)
+        sublabel = _BIDDER_SUBLABELS.get(bidder_id, "")
         passed = sum(1 for v in verdicts
                      if v["verdict"] == "eligible" and
                      crit_map.get(v["criterion_id"]) and
                      crit_map[v["criterion_id"]].mandatory)
+        total_mand = sum(1 for v in verdicts
+                         if crit_map.get(v["criterion_id"]) and
+                         crit_map[v["criterion_id"]].mandatory)
 
         with st.container(border=True):
+            # Bidder header
             st.markdown(
-                f"#### {friendly}  —  Overall: {overall_pill}"
-                f"  <span style='font-size:0.85em; color:grey;'>"
-                f"({passed}/{mandatory_count} mandatory criteria met)</span>",
+                f"""<div style="display:flex;justify-content:space-between;
+                            align-items:center;flex-wrap:wrap;gap:8px;
+                            padding:4px 0 12px;">
+                <div>
+                    <div style="font-size:1.05rem;font-weight:700;color:#0D1B2A;">{friendly}</div>
+                    <div style="font-size:0.8rem;color:#64748B;margin-top:2px;">{sublabel}</div>
+                </div>
+                <div style="display:flex;align-items:center;gap:12px;">
+                    {op}
+                    <span style="font-size:0.78rem;color:#94A3B8;background:#F1F5F9;
+                                 padding:3px 10px;border-radius:20px;">
+                        {passed}/{total_mand} mandatory passed
+                    </span>
+                </div>
+                </div>""",
                 unsafe_allow_html=True,
             )
 
             # Column headers
-            hcols = st.columns([3, 2, 2, 2, 1])
-            hcols[0].caption("Criterion")
-            hcols[1].caption("Verdict")
-            hcols[2].caption("Extracted Value")
-            hcols[3].caption("Source / OCR Tier")
-            hcols[4].caption("Category")
-            st.divider()
+            hcols = st.columns([3, 2, 2, 3, 2])
+            for col, lbl in zip(hcols, ["Criterion", "Verdict", "Extracted Value",
+                                         "Source & OCR Tier", "Category"]):
+                col.markdown(
+                    f'<div style="font-size:0.72rem;font-weight:700;color:#94A3B8;'
+                    f'text-transform:uppercase;letter-spacing:0.06em;padding-bottom:4px;">'
+                    f'{lbl}</div>',
+                    unsafe_allow_html=True,
+                )
+            st.markdown('<hr style="margin:0 0 8px;border-color:#F1F5F9;">', unsafe_allow_html=True)
 
             for v in verdicts:
                 crit = crit_map.get(v["criterion_id"])
                 crit_title = crit.title if crit else v["criterion_id"]
-                mandatory_tag = "🔴" if (crit and crit.mandatory) else "🟡"
+                mb = mandatory_badge(crit.mandatory if crit else True)
                 cat = category_badge(crit.category if crit else "compliance")
 
-                cols = st.columns([3, 2, 2, 2, 1])
-                cols[0].markdown(f"{mandatory_tag} **{v['criterion_id']}** {crit_title}")
-                cols[1].markdown(verdict_pill(v["verdict"]))
-                cols[2].markdown(f"{v.get('extracted_value') or '—'}")
+                cols = st.columns([3, 2, 2, 3, 2])
+                cols[0].markdown(
+                    f'{mb} <span style="font-weight:600;font-size:0.88rem;">'
+                    f'{v["criterion_id"]}</span>'
+                    f'<div style="font-size:0.8rem;color:#374151;margin-top:2px;">{crit_title}</div>',
+                    unsafe_allow_html=True,
+                )
+                cols[1].markdown(verdict_pill(v["verdict"]), unsafe_allow_html=True)
+                extracted = v.get("extracted_value") or ""
+                extracted_html = (
+                    f'<span style="font-size:0.85rem;color:#374151;">{extracted}</span>'
+                    if extracted else
+                    '<span style="color:#9CA3AF;">—</span>'
+                )
+                cols[2].markdown(extracted_html, unsafe_allow_html=True)
                 if v.get("source"):
                     src = v["source"]
                     tier = ocr_tier_badge(src["source_type"])
-                    cols[3].markdown(f"`{src['doc_name']}` p{src['page']}  {tier}")
+                    cols[3].markdown(
+                        f'<span style="font-size:0.82rem;font-family:monospace;'
+                        f'background:#F8FAFC;padding:2px 6px;border-radius:4px;'
+                        f'border:1px solid #E2E8F0;">{src["doc_name"]}</span>'
+                        f' p{src["page"]}<br>{tier}',
+                        unsafe_allow_html=True,
+                    )
                 else:
-                    cols[3].markdown("—")
-                cols[4].markdown(cat)
+                    cols[3].markdown('<span style="color:#9CA3AF;">—</span>', unsafe_allow_html=True)
+                cols[4].markdown(cat, unsafe_allow_html=True)
 
-                conf = v.get("combined_confidence", 0.0)
-                confidence_bar(conf)
+                confidence_bar(v.get("combined_confidence", 0.0))
 
                 if v.get("reason") or (v.get("source") and v["source"].get("snippet")):
-                    with st.expander("Details", expanded=False):
+                    with st.expander("View details", expanded=False):
                         if v.get("reason"):
-                            st.markdown(f"**Reason:** {v['reason']}")
+                            st.markdown(
+                                f'<div style="background:#F8FAFC;border-left:3px solid #3B82F6;'
+                                f'padding:10px 14px;border-radius:0 6px 6px 0;'
+                                f'font-size:0.88rem;color:#374151;">'
+                                f'<strong>Reason:</strong> {v["reason"]}</div>',
+                                unsafe_allow_html=True,
+                            )
                         if v.get("source") and v["source"].get("snippet"):
-                            st.markdown(f"**Source snippet:** _{v['source']['snippet']}_")
-                st.divider()
+                            st.markdown(
+                                f'<div style="background:#FFFBEB;border-left:3px solid #F59E0B;'
+                                f'padding:10px 14px;border-radius:0 6px 6px 0;margin-top:8px;'
+                                f'font-size:0.85rem;color:#374151;font-style:italic;">'
+                                f'"{v["source"]["snippet"]}"</div>',
+                                unsafe_allow_html=True,
+                            )
+                st.markdown('<hr style="margin:6px 0;border-color:#F1F5F9;">', unsafe_allow_html=True)

ui/tab_interpretability.py

@@ -262,13 +262,13 @@ def render() -> None:
                             try:
                                 img = render_page_to_image(doc_path, page_no)
                                 st.image(img, caption=f"{doc_name} — Page {page_no}",
-                                         use_container_width=True)
+                                         use_column_width=True)
                             except Exception:
                                 st.caption("Page preview unavailable.")
                     elif doc_path.exists() and doc_path.suffix.lower() in {".png", ".jpg"}:
                         with st.expander(f"View source image ({doc_name})", expanded=False):
                             st.image(str(doc_path), caption=doc_name,
-                                     use_container_width=True)
+                                     use_column_width=True)
 
     st.divider()
 

ui/tab_overview.py

@@ -6,14 +6,20 @@ from core.fallback import load_criteria
 
 
 def render() -> None:
-    st.header("⚖️ TenderIQ — Explainable AI for Tender Evaluation")
+    # Hero banner
     st.markdown(
-        "Automated eligibility evaluation of bidders against government tender criteria, "
-        "with criterion-level explainability, OCR for scanned documents, and a complete audit trail."
+        """<div class="tiq-hero">
+        <h1>⚖️ TenderIQ</h1>
+        <p>Explainable AI for Government Tender Evaluation &nbsp;·&nbsp;
+           CRPF Hackathon Theme 3</p>
+        <p style="font-size:0.88rem;margin-top:8px;color:#94A3B8;">
+        Automated eligibility evaluation with criterion-level explainability,
+        three-tier OCR for scanned documents, and a complete audit trail.</p>
+        </div>""",
+        unsafe_allow_html=True,
     )
-    st.divider()
 
-    # KPI cards
+    # KPI strip
     criteria_count = len(st.session_state.get("criteria", load_criteria()))
     verdicts = st.session_state.get("verdicts", {})
     bidders_evaluated = len(verdicts)
@@ -24,120 +30,87 @@ def render() -> None:
     audit_entries = len(audit.query())
 
     c1, c2, c3, c4 = st.columns(4)
-    c1.metric("Criteria Extracted", criteria_count)
-    c2.metric("Bidders Evaluated", bidders_evaluated)
-    c3.metric("Criteria Checked", mandatory_checked)
-    c4.metric("Audit Entries", audit_entries)
+    for col, val, lbl in [
+        (c1, criteria_count,    "Criteria Extracted"),
+        (c2, bidders_evaluated, "Bidders Evaluated"),
+        (c3, mandatory_checked, "Criteria Checked"),
+        (c4, audit_entries,     "Audit Entries"),
+    ]:
+        col.markdown(
+            f'<div class="tiq-kpi">'
+            f'<div class="tiq-kpi-val">{val}</div>'
+            f'<div class="tiq-kpi-lbl">{lbl}</div>'
+            f'</div>',
+            unsafe_allow_html=True,
+        )
 
     st.divider()
 
-    # Architecture diagram
-    st.subheader("System Architecture")
-    st.markdown("""
-```
-┌─────────────────────────────────────────────────────────────────────┐
-│                        TenderIQ Pipeline                            │
-└─────────────────────────────────────────────────────────────────────┘
-
-  📄 Tender PDF                      📁 Bidder Documents
-       │                              (PDFs, scans, photos)
-       │                                      │
-       ▼                                      ▼
- ┌───────────┐                    ┌────────────────────────┐
- │  DeepSeek │                    │   3-Tier OCR Pipeline  │
- │    LLM    │                    │  ① PyMuPDF  (typed)   │
- │ (Stage 1) │                    │  ② Tesseract (scans)  │
- └───────────┘                    │  ③ Vision LLM (poor)  │
-       │                          └────────────────────────┘
-       │                                      │
-       ▼                                      ▼
- ┌───────────┐                    ┌────────────────────────┐
- │ Criteria  │                    │   ChromaDB Vector      │
- │  C1 – C5  │                    │   Index (per bidder)   │
- │ (JSON)    │                    └────────────────────────┘
- └───────────┘                                │
-       │                                      │  semantic search
-       └──────────────────┬───────────────────┘
-                          │
-                          ▼
-               ┌─────────────────────┐
-               │   DeepSeek LLM      │
-               │   (Stage 3 eval)    │
-               │                     │
-               │  evidence → verdict │
-               │  + confidence score │
-               └─────────────────────┘
-                          │
-            ┌─────────────┴──────────────┐
-            │                            │
-            ▼                            ▼
-   confidence ≥ 0.80            confidence < 0.80
-   verdict kept                 downgraded to
-                                needs_review
-                                      │
-                                      ▼
-                             ┌─────────────────┐
-                             │  Human Review   │
-                             │  Queue (Tab 4)  │
-                             └─────────────────┘
-                                      │
-                                      ▼
-                             ┌─────────────────┐
-                             │   Audit Log     │
-                             │  (every action) │
-                             └─────────────────┘
-```
-""")
-
-    st.divider()
+    # Architecture
+    st.markdown('<div class="tiq-section-header"><div style="font-size:1.1rem;font-weight:700;color:#0D1B2A;">Pipeline Architecture</div></div>', unsafe_allow_html=True)
 
-    st.subheader("Pipeline Stages")
     col_a, col_b = st.columns(2)
     with col_a:
         st.markdown("""
-**① Extract Criteria**
-DeepSeek reads the full tender PDF and extracts each eligibility criterion as structured JSON —
-category, mandatory flag, rule (threshold / certification / count), source clause, and query hints
-for downstream retrieval.
-
-**② OCR & Index Bidder Documents**
-Three-tier pipeline handles any document format:
-PyMuPDF for typed PDFs (instant, lossless) →
-Tesseract for scans (free, fast) →
-DeepSeek Vision LLM when Tesseract confidence < 65%.
-All text is chunked and indexed into ChromaDB with full provenance metadata.
-""")
+<div style="background:#F8FAFC;border:1px solid #E2E8F0;border-radius:12px;padding:20px;">
+<div style="font-weight:700;color:#1E3A5F;margin-bottom:12px;">📥 Ingestion</div>
+
+<div style="display:flex;align-items:flex-start;gap:10px;margin-bottom:10px;">
+<div style="background:#DBEAFE;color:#1E40AF;border-radius:6px;padding:3px 8px;font-size:0.75rem;font-weight:700;flex-shrink:0;">1</div>
+<div><strong>Extract Criteria</strong><br><span style="font-size:0.82rem;color:#64748B;">DeepSeek LLM reads the full tender PDF and returns structured JSON — category, mandatory flag, rule, source clause, query hints.</span></div>
+</div>
+
+<div style="display:flex;align-items:flex-start;gap:10px;">
+<div style="background:#DBEAFE;color:#1E40AF;border-radius:6px;padding:3px 8px;font-size:0.75rem;font-weight:700;flex-shrink:0;">2</div>
+<div><strong>Three-Tier OCR</strong><br><span style="font-size:0.82rem;color:#64748B;">
+📄 PyMuPDF → 🔍 Tesseract → 👁 Vision LLM.<br>
+Each page records its tier and confidence score.
+Chunks indexed into ChromaDB with full provenance.</span></div>
+</div>
+</div>
+""", unsafe_allow_html=True)
+
     with col_b:
         st.markdown("""
-**③ Evaluate per Criterion**
-For each (bidder × criterion) pair: semantic search retrieves the most relevant evidence chunks,
-DeepSeek decides eligible / not_eligible / needs_review with a combined confidence score
-that weights LLM certainty against OCR quality.
-The safety rule: never silently disqualify — borderline cases always go to human review.
-
-**④ Human Review & Audit**
-Flagged verdicts surface in the Review Queue with full evidence and source citations.
-Every action — extraction, indexing, evaluation, review — is logged to SQLite with
-timestamp, model version, actor, and payload.
-""")
+<div style="background:#F8FAFC;border:1px solid #E2E8F0;border-radius:12px;padding:20px;">
+<div style="font-weight:700;color:#1E3A5F;margin-bottom:12px;">⚖️ Evaluation & Oversight</div>
+
+<div style="display:flex;align-items:flex-start;gap:10px;margin-bottom:10px;">
+<div style="background:#DCFCE7;color:#166534;border-radius:6px;padding:3px 8px;font-size:0.75rem;font-weight:700;flex-shrink:0;">3</div>
+<div><strong>Evaluate per Criterion</strong><br><span style="font-size:0.82rem;color:#64748B;">Semantic search retrieves top-k evidence chunks. DeepSeek returns verdict + confidence. Safety rule: borderline "not eligible" is downgraded to "needs review" — never silent disqualification.</span></div>
+</div>
+
+<div style="display:flex;align-items:flex-start;gap:10px;">
+<div style="background:#FEF3C7;color:#92400E;border-radius:6px;padding:3px 8px;font-size:0.75rem;font-weight:700;flex-shrink:0;">4</div>
+<div><strong>Human Review & Audit</strong><br><span style="font-size:0.82rem;color:#64748B;">Flagged verdicts surface with full evidence. Every action — extraction, OCR, evaluation, review — is logged to SQLite with timestamp, model version, and payload.</span></div>
+</div>
+</div>
+""", unsafe_allow_html=True)
 
     st.divider()
 
-    st.subheader("Quick Start")
+    # Quick start
+    st.markdown('<div class="tiq-section-header"><div style="font-size:1.1rem;font-weight:700;color:#0D1B2A;">Quick Start</div></div>', unsafe_allow_html=True)
+
     col1, col2 = st.columns(2)
     with col1:
-        if st.button("Load Pre-computed Demo", type="primary", use_container_width=True):
-            from core.fallback import load_criteria as lc, load_evaluation
-            criteria = lc()
-            st.session_state["criteria"] = [c.model_dump() for c in criteria]
-            verdicts_dict: dict = {}
-            for bidder_id in BIDDER_NAMES:
-                verdicts_dict[bidder_id] = [
-                    load_evaluation(bidder_id, c.id).model_dump()
-                    for c in criteria
-                ]
-            st.session_state["verdicts"] = verdicts_dict
-            st.success("Pre-computed demo loaded. Navigate to the other tabs.")
-            st.rerun()
+        with st.container(border=True):
+            st.markdown("**🚀 Pre-computed Demo**")
+            st.caption("Instantly load realistic results for all 3 bidders — no API key needed.")
+            if st.button("Load Pre-computed Demo", type="primary", use_container_width=True):
+                from core.fallback import load_criteria as lc, load_evaluation
+                criteria = lc()
+                st.session_state["criteria"] = [c.model_dump() for c in criteria]
+                verdicts_dict: dict = {}
+                for bidder_id in BIDDER_NAMES:
+                    verdicts_dict[bidder_id] = [
+                        load_evaluation(bidder_id, c.id).model_dump() for c in criteria
+                    ]
+                st.session_state["verdicts"] = verdicts_dict
+                st.success("Loaded. Navigate to Bidder Evaluation or Interpretability.")
+                st.rerun()
     with col2:
-        st.info("Or go to **Tender Analysis** to run the live LLM pipeline.")
+        with st.container(border=True):
+            st.markdown("**⚡ Live Pipeline**")
+            st.caption("Upload a tender PDF, run extraction and evaluation against the DeepSeek API.")
+            st.info("Set `DEEPSEEK_API_KEY` in `.env`, then use the Tender Analysis tab.")

ui/tab_review.py

@@ -1,6 +1,7 @@
 import streamlit as st
 
 from core import audit
+from core.config import BIDDER_NAMES
 from core.fallback import load_criteria
 from core.schemas import Criterion
 from ui.components import confidence_bar, verdict_pill
@@ -46,15 +47,39 @@ def render() -> None:
 
         with st.container(border=True):
             col1, col2 = st.columns([3, 1])
+            friendly = BIDDER_NAMES.get(bidder_id, bidder_id)
             with col1:
-                st.markdown(f"**{bidder_id}** — {v['criterion_id']}: {crit_title}")
-                st.markdown(f"Verdict: {verdict_pill(v['verdict'])}")
+                st.markdown(
+                    f'<div style="font-weight:700;font-size:1rem;color:#0D1B2A;">'
+                    f'{friendly}</div>'
+                    f'<div style="font-size:0.85rem;color:#64748B;margin-top:2px;">'
+                    f'{v["criterion_id"]}: {crit_title}</div>',
+                    unsafe_allow_html=True,
+                )
+                st.markdown(verdict_pill(v["verdict"]), unsafe_allow_html=True)
                 if v.get("extracted_value"):
-                    st.markdown(f"Extracted value: `{v['extracted_value']}`")
+                    st.markdown(
+                        f'<div style="margin-top:6px;font-size:0.85rem;">'
+                        f'<strong>Extracted value:</strong> '
+                        f'<code>{v["extracted_value"]}</code></div>',
+                        unsafe_allow_html=True,
+                    )
                 if v.get("reason"):
-                    st.markdown(f"Reason: _{v['reason']}_")
+                    st.markdown(
+                        f'<div style="background:#FFFBEB;border-left:3px solid #F59E0B;'
+                        f'padding:8px 12px;border-radius:0 6px 6px 0;margin-top:8px;'
+                        f'font-size:0.85rem;color:#374151;">'
+                        f'<strong>Reason:</strong> {v["reason"]}</div>',
+                        unsafe_allow_html=True,
+                    )
                 if v.get("source") and v["source"].get("snippet"):
-                    st.markdown(f"Source snippet: _{v['source']['snippet']}_")
+                    st.markdown(
+                        f'<div style="background:#F8FAFC;border:1px solid #E2E8F0;'
+                        f'padding:8px 12px;border-radius:6px;margin-top:6px;'
+                        f'font-size:0.82rem;color:#374151;font-style:italic;">'
+                        f'"{v["source"]["snippet"]}"</div>',
+                        unsafe_allow_html=True,
+                    )
             with col2:
                 conf = v.get("combined_confidence", 0.0)
                 confidence_bar(conf, "Certainty in assessment")