Step 12: UI tabs — full bidder evaluation, review queue, audit log, overview

Implements specs/13_ui_tabs.md. Tab 1: KPI cards + demo CTA. Tab 2: criteria
extraction (Step 6). Tab 3: multi-bidder evaluation with verdict pills,
confidence bars, OCR-tier badges, and expandable details. Tab 4: human review
queue with Approve/Edit/Reject. Tab 5: sortable audit log with CSV export.
Sidebar: live DeepSeek connection probe with green/amber/red status dot.

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

app.py

@@ -12,13 +12,42 @@ st.set_page_config(
     layout="wide",
 )
 
+
+def _probe_llm() -> str:
+    """Returns 'green', 'amber', or 'red'."""
+    if st.session_state.get("fallback_active"):
+        return "amber"
+    if "llm_status" in st.session_state:
+        return st.session_state["llm_status"]
+    from core.llm_client import LLM, LLMUnavailable
+    try:
+        LLM().chat_json("Respond with valid JSON only.", '{"ping": true}')
+        st.session_state["llm_status"] = "green"
+        return "green"
+    except LLMUnavailable:
+        st.session_state["llm_status"] = "red"
+        return "red"
+    except Exception:
+        st.session_state["llm_status"] = "red"
+        return "red"
+
+
 # ── Sidebar ──────────────────────────────────────────────────────────────────
 with st.sidebar:
     st.markdown("## ⚖️ TenderIQ")
     st.caption("Explainable AI for Tender Evaluation")
     st.divider()
-    # Connection status — placeholder until core/llm_client.py is wired
-    st.markdown("🔴 **DeepSeek:** not connected")
+
+    status = _probe_llm()
+    if status == "green":
+        st.markdown("🟢 **DeepSeek:** connected")
+    elif status == "amber":
+        st.markdown("🟡 **DeepSeek:** pre-computed mode")
+        st.warning("⚠ Pre-computed results active.")
+    else:
+        st.markdown("🔴 **DeepSeek:** not connected")
+        st.caption("Using pre-computed fallback data.")
+
     st.divider()
     if st.button("Reset Session", use_container_width=True):
         for key in list(st.session_state.keys()):

specs/13_ui_tabs.md

@@ -0,0 +1,121 @@
+# Spec 13 — UI Tabs
+
+**Step:** 12 of 15  
+**Time budget:** ~80 min total
+
+---
+
+## Goal
+
+Implement all five Streamlit tabs and `ui/components.py`. The app must render the full demo flow without an API key (using precomputed data), and with one (calling the live LLM).
+
+---
+
+## `ui/components.py` — Shared widgets
+
+### `verdict_pill(verdict: str) -> str`
+Returns a markdown-formatted colored badge string:
+- `eligible` → `":green[✅ Eligible]"`
+- `not_eligible` → `":red[❌ Not Eligible]"`
+- `needs_review` → `":orange[⚠ Needs Review]"`
+
+### `confidence_bar(value: float, label: str = "Confidence") -> None`
+Renders `st.progress(value, text=f"{label}: {value:.0%}")`.
+
+### `ocr_tier_badge(source_type: str) -> str`
+Returns a short badge string:
+- `text_pdf` → "`📄 text_pdf`"
+- `tesseract` → "`🔍 tesseract`"
+- `vision_llm` → "`👁 vision_llm`"
+
+### `category_badge(category: str) -> str`
+Returns `":blue[financial]"`, `":green[technical]"`, or `":orange[compliance]"`.
+
+---
+
+## Tab 1 — Overview (`ui/tab_overview.py`)
+
+Layout:
+1. Hero text + tagline.
+2. Two-column KPI cards: Criteria Extracted, Bidders Evaluated, Mandatory Criteria Checked, Audit Entries Logged.
+3. Architecture summary (text description since no image file yet).
+4. "Use Pre-loaded Demo Data" CTA that sets `st.session_state["use_demo"] = True` and shows the criteria count from the fallback file.
+
+KPI values: count from `st.session_state` data and `audit.query()`.
+
+---
+
+## Tab 2 — Tender Analysis (`ui/tab_tender.py`)
+
+Already implemented in Step 6. No changes needed beyond what's there.
+
+---
+
+## Tab 3 — Bidder Evaluation (`ui/tab_bidders.py`)
+
+Layout:
+1. `st.header("Bidder Evaluation")`
+2. Multi-select for bidders: `["bidder_a", "bidder_b", "bidder_c"]`, default all.
+3. Button **"Run Evaluation"** (type=primary).
+4. On click:
+   a. Ensure criteria are loaded (from session_state or fallback).
+   b. For each selected bidder: `process_bidder(...)`, then `evaluate_bidder(...)`.
+   c. Store verdicts in `st.session_state["verdicts"]` as `{bidder_id: [Verdict.model_dump(), ...]}`.
+5. If verdicts in session:
+   - For each bidder: show per-bidder summary header.
+   - Show a table of criteria rows using `st.columns`.
+   - Each row: criterion title, verdict pill, extracted value, source chip (doc + page), OCR-tier badge, confidence bar.
+   - Expandable "Reason" and "Source Snippet" per row.
+
+Per-bidder summary: count eligible/not_eligible/needs_review among mandatory criteria. Overall: Eligible only if all mandatory are eligible; Not Eligible if any are not_eligible; Needs Review otherwise.
+
+---
+
+## Tab 4 — Human Review Queue (`ui/tab_review.py`)
+
+Layout:
+1. `st.header("Human Review Queue")`
+2. Shows all verdicts where `review_status == "pending"` AND `verdict == "needs_review"`.
+3. For each such verdict:
+   - Show: bidder_id, criterion title, extracted value, confidence, reason, source snippet.
+   - Three buttons: **Approve**, **Edit & Approve**, **Reject**.
+   - **Approve**: set `review_status = "approved"`, log `human_review_action` to audit.
+   - **Edit & Approve**: show `st.text_input` for edited value, set `review_status = "edited"`, log audit.
+   - **Reject**: set `review_status = "rejected"`, log audit.
+4. If no pending items: `st.success("No items pending review.")`.
+
+State: verdicts stored in `st.session_state["verdicts"]` as nested dicts. Updates write back to the same structure.
+
+---
+
+## Tab 5 — Audit Log (`ui/tab_audit.py`)
+
+Layout:
+1. `st.header("Audit Log")`
+2. Filter row: bidder dropdown, action dropdown, date range.
+3. Table: `st.dataframe` with columns: ts, action, actor, bidder_id, criterion_id, payload_json.
+4. **"Export CSV"** button: `st.download_button` with CSV data from filtered rows.
+
+---
+
+## Sidebar update (`app.py`)
+
+Replace the hardcoded "🔴 **DeepSeek:** not connected" with a live probe:
+- Try `LLM().chat_json("ping", '{"ping": true}')` at startup (cached with session_state).
+- Green: live and no fallback fired.
+- Amber: fallback has fired this session.
+- Red: probe failed.
+
+If `st.session_state.get("fallback_active")`: show `st.sidebar.warning("⚠ Pre-computed mode active.")`.
+
+---
+
+## Acceptance Criteria
+
+1. Tab 1 renders without error and shows KPI cards.
+2. Tab 3 "Run Evaluation" populates the verdict table for all 3 bidders.
+3. Bidder A shows all mandatory criteria eligible. Bidder B shows C1 not_eligible.
+4. Tab 4 shows at least one pending review item for Bidder C.
+5. Tab 4 Approve button updates `review_status` and adds an audit entry.
+6. Tab 5 shows audit entries and CSV download works.
+7. Sidebar connection dot is green/amber/red based on API availability.

ui/components.py

@@ -1 +1,33 @@
-# Shared UI widgets — implemented incrementally as Tab 3 and Tab 4 need them.
+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]"
+
+
+def confidence_bar(value: float, label: str = "Confidence") -> None:
+    st.progress(min(max(value, 0.0), 1.0), text=f"{label}: {value:.0%}")
+
+
+def ocr_tier_badge(source_type: str) -> str:
+    icons = {
+        "text_pdf": "📄 text_pdf",
+        "tesseract": "🔍 tesseract",
+        "vision_llm": "👁 vision_llm",
+    }
+    return icons.get(source_type, f"❓ {source_type}")
+
+
+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

ui/tab_audit.py

@@ -1,5 +1,55 @@
+import io
+
+import pandas as pd
 import streamlit as st
 
+from core import audit
+
+
 def render() -> None:
     st.header("Audit Log")
-    st.info("Coming soon — sortable audit log with CSV export.")
+
+    col1, col2, col3 = st.columns(3)
+    with col1:
+        bidder_filter = st.selectbox(
+            "Filter by bidder",
+            options=["All", "bidder_a", "bidder_b", "bidder_c"],
+        )
+    with col2:
+        action_filter = st.selectbox(
+            "Filter by action",
+            options=["All", "criteria_extracted", "bidder_processed", "criterion_evaluated",
+                     "human_review_action", "precomputed_fallback_used", "vision_ocr_invoked"],
+        )
+    with col3:
+        st.markdown(" ")  # spacer
+
+    filters: dict = {}
+    if bidder_filter != "All":
+        filters["bidder_id"] = bidder_filter
+    if action_filter != "All":
+        filters["action"] = action_filter
+
+    rows = audit.query(filters if filters else None)
+
+    if not rows:
+        st.info("No audit entries yet. Run an evaluation to generate entries.")
+        return
+
+    df = pd.DataFrame(rows)
+    display_cols = ["id", "ts", "action", "actor", "bidder_id", "criterion_id", "payload_json"]
+    display_cols = [c for c in display_cols if c in df.columns]
+    df_display = df[display_cols].copy()
+    df_display["ts"] = df_display["ts"].str[:19].str.replace("T", " ")
+
+    st.markdown(f"**{len(rows)} entries** (newest first)")
+    st.dataframe(df_display, use_container_width=True, hide_index=True)
+
+    csv_buf = io.StringIO()
+    df_display.to_csv(csv_buf, index=False)
+    st.download_button(
+        label="Export CSV",
+        data=csv_buf.getvalue().encode("utf-8"),
+        file_name="tenderiq_audit_log.csv",
+        mime="text/csv",
+    )

ui/tab_bidders.py

@@ -1,5 +1,114 @@
+from pathlib import Path
+
 import streamlit as st
 
+from core import bidder_processor, evaluator
+from core.config import 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
+
+_BIDDER_LABELS = {
+    "bidder_a": "Bidder A — Apex Constructions (Clearly Eligible)",
+    "bidder_b": "Bidder B — BuildRight Enterprises (Ineligible: Low Turnover)",
+    "bidder_c": "Bidder C — Shree Constructions (Scanned Cert: Needs Review)",
+}
+
+
+def _get_criteria() -> list[Criterion]:
+    data = st.session_state.get("criteria")
+    if data:
+        return [Criterion(**c) for c in data]
+    return load_criteria()
+
+
+def _overall_verdict(verdicts: list[dict]) -> str:
+    mandatory = [v for v in verdicts if True]  # all criteria checked
+    if any(v["verdict"] == "not_eligible" for v in mandatory):
+        return "not_eligible"
+    if any(v["verdict"] == "needs_review" for v in mandatory):
+        return "needs_review"
+    return "eligible"
+
+
 def render() -> None:
     st.header("Bidder Evaluation")
-    st.info("Coming soon — per-bidder, per-criterion verdict table.")
+
+    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),
+    )
+
+    if st.button("Run Evaluation", type="primary"):
+        criteria = _get_criteria()
+        verdicts_dict: dict = {}
+        progress = st.progress(0, text="Starting evaluation…")
+        total = len(selected) * len(criteria)
+        done = 0
+        for bidder_id in selected:
+            files = sorted(
+                f for f in (DATA_DIR / "bidders" / bidder_id).iterdir()
+                if f.suffix.lower() in {".pdf", ".png", ".jpg"}
+            )
+            with st.spinner(f"Processing {bidder_id} documents…"):
+                bidder_processor.process_bidder(bidder_id, files)
+            verdicts_list = []
+            for c in criteria:
+                v = evaluator.evaluate(bidder_id, c)
+                verdicts_list.append(v.model_dump())
+                done += 1
+                progress.progress(done / total, text=f"Evaluated {c.id} for {bidder_id}")
+            verdicts_dict[bidder_id] = verdicts_list
+        st.session_state["verdicts"] = verdicts_dict
+        progress.empty()
+        st.success("Evaluation complete.")
+        st.rerun()
+
+    verdicts_data = st.session_state.get("verdicts", {})
+    criteria = _get_criteria()
+    crit_map = {c.id: c for c in criteria}
+
+    if st.session_state.get("fallback_active"):
+        st.warning("⚠ Live API unavailable — showing pre-computed results.")
+
+    for bidder_id in (selected or list(verdicts_data.keys())):
+        if bidder_id not in verdicts_data:
+            continue
+        verdicts = verdicts_data[bidder_id]
+        overall = _overall_verdict(verdicts)
+        overall_pill = verdict_pill(overall)
+
+        with st.expander(
+            f"**{_BIDDER_LABELS.get(bidder_id, bidder_id)}**  —  Overall: {overall_pill}",
+            expanded=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 "🟡"
+                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 '—'}")
+                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}")
+                else:
+                    cols[3].markdown("—")
+                cols[4].markdown(cat)
+
+                conf = v.get("combined_confidence", 0.0)
+                confidence_bar(conf)
+
+                if v.get("reason") or v.get("source"):
+                    with st.expander("Details", expanded=False):
+                        if v.get("reason"):
+                            st.markdown(f"**Reason:** {v['reason']}")
+                        if v.get("source") and v["source"].get("snippet"):
+                            st.markdown(f"**Source snippet:** _{v['source']['snippet']}_")
+                st.divider()

ui/tab_overview.py

@@ -1,5 +1,71 @@
 import streamlit as st
 
+from core import audit
+from core.fallback import load_criteria
+
+
 def render() -> None:
-    st.header("Overview")
-    st.info("Coming soon — architecture diagram, KPIs, and demo CTA.")
+    st.header("⚖️ TenderIQ — Explainable AI for Tender Evaluation")
+    st.markdown(
+        "Automated eligibility evaluation of bidders against government tender criteria, "
+        "with criterion-level explainability, OCR for scanned documents, and a complete audit trail."
+    )
+    st.divider()
+
+    # KPI cards
+    criteria_count = len(st.session_state.get("criteria", load_criteria()))
+    verdicts = st.session_state.get("verdicts", {})
+    bidders_evaluated = len(verdicts)
+    mandatory_checked = sum(
+        1 for bv in verdicts.values() for v in bv
+        if v.get("verdict") in ("eligible", "not_eligible", "needs_review")
+    )
+    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)
+
+    st.divider()
+
+    st.subheader("How it works")
+    col_a, col_b = st.columns(2)
+    with col_a:
+        st.markdown("""
+**Stage 1 — Extract Criteria**
+DeepSeek LLM reads the tender PDF and extracts each eligibility criterion as structured JSON (category, rule, query hints).
+
+**Stage 2 — OCR & Index Bidder Docs**
+Three-tier OCR: PyMuPDF (typed PDF) → Tesseract → DeepSeek Vision LLM (low-confidence scans). All pages indexed into ChromaDB.
+""")
+    with col_b:
+        st.markdown("""
+**Stage 3 — Evaluate per Criterion**
+Vector search retrieves relevant evidence chunks. DeepSeek evaluates eligible / not_eligible / needs_review with a combined confidence score.
+
+**Stage 4 — Human Review & Audit**
+Low-confidence verdicts are routed to the review queue. Every action is logged with timestamp, model version, and payload.
+""")
+
+    st.divider()
+
+    st.subheader("Quick Start")
+    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_a", "bidder_b", "bidder_c"]:
+                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 data loaded. Navigate to the other tabs.")
+            st.rerun()
+    with col2:
+        st.info("Or go to **Tender Analysis** tab to run the live LLM pipeline.")

ui/tab_review.py

@@ -1,5 +1,99 @@
 import streamlit as st
 
+from core import audit
+from core.fallback import load_criteria
+from core.schemas import Criterion
+from ui.components import confidence_bar, verdict_pill
+
+
+def _get_criteria_map() -> dict[str, Criterion]:
+    data = st.session_state.get("criteria")
+    if data:
+        return {c["id"]: Criterion(**c) for c in data}
+    return {c.id: c for c in load_criteria()}
+
+
 def render() -> None:
     st.header("Human Review Queue")
-    st.info("Coming soon — approve / edit / reject flagged verdicts.")
+
+    verdicts_data: dict = st.session_state.get("verdicts", {})
+    if not verdicts_data:
+        st.info("No evaluation results yet. Run the evaluation in the Bidder Evaluation tab first.")
+        return
+
+    crit_map = _get_criteria_map()
+    pending_items = []
+    for bidder_id, verdicts in verdicts_data.items():
+        for i, v in enumerate(verdicts):
+            if v.get("verdict") == "needs_review" and v.get("review_status", "pending") == "pending":
+                pending_items.append((bidder_id, i, v))
+
+    if not pending_items:
+        st.success("No items pending review. All flagged verdicts have been actioned.")
+        return
+
+    st.markdown(f"**{len(pending_items)} item(s) pending review**")
+    st.divider()
+
+    for bidder_id, idx, v in pending_items:
+        crit = crit_map.get(v["criterion_id"])
+        crit_title = crit.title if crit else v["criterion_id"]
+
+        with st.container(border=True):
+            col1, col2 = st.columns([3, 1])
+            with col1:
+                st.markdown(f"**{bidder_id}** — {v['criterion_id']}: {crit_title}")
+                st.markdown(f"Verdict: {verdict_pill(v['verdict'])}")
+                if v.get("extracted_value"):
+                    st.markdown(f"Extracted value: `{v['extracted_value']}`")
+                if v.get("reason"):
+                    st.markdown(f"Reason: _{v['reason']}_")
+                if v.get("source") and v["source"].get("snippet"):
+                    st.markdown(f"Source snippet: _{v['source']['snippet']}_")
+            with col2:
+                conf = v.get("combined_confidence", 0.0)
+                confidence_bar(conf, "Confidence")
+
+            btn_col1, btn_col2, btn_col3 = st.columns(3)
+            key_prefix = f"review_{bidder_id}_{v['criterion_id']}"
+
+            with btn_col1:
+                if st.button("✅ Approve", key=f"{key_prefix}_approve", use_container_width=True):
+                    st.session_state["verdicts"][bidder_id][idx]["review_status"] = "approved"
+                    audit.log(
+                        "human_review_action",
+                        actor="officer",
+                        bidder_id=bidder_id,
+                        criterion_id=v["criterion_id"],
+                        action_taken="approved",
+                    )
+                    st.rerun()
+
+            with btn_col2:
+                edit_val = st.text_input("Edited value", key=f"{key_prefix}_edit_val",
+                                          placeholder="Enter corrected value…")
+                if st.button("✏ Edit & Approve", key=f"{key_prefix}_edit", use_container_width=True):
+                    st.session_state["verdicts"][bidder_id][idx]["review_status"] = "edited"
+                    if edit_val:
+                        st.session_state["verdicts"][bidder_id][idx]["extracted_value"] = edit_val
+                    audit.log(
+                        "human_review_action",
+                        actor="officer",
+                        bidder_id=bidder_id,
+                        criterion_id=v["criterion_id"],
+                        action_taken="edited",
+                        edited_value=edit_val,
+                    )
+                    st.rerun()
+
+            with btn_col3:
+                if st.button("❌ Reject", key=f"{key_prefix}_reject", use_container_width=True):
+                    st.session_state["verdicts"][bidder_id][idx]["review_status"] = "rejected"
+                    audit.log(
+                        "human_review_action",
+                        actor="officer",
+                        bidder_id=bidder_id,
+                        criterion_id=v["criterion_id"],
+                        action_taken="rejected",
+                    )
+                    st.rerun()