feat: implement 6 Streamlit components + FE services with 68 TDD tests

Components (return render specs for testability):
- file_uploader: multi-file PDF/image upload spec
- profile_card: PatientProfile display with prescreen data check
- trial_card: traffic-light eligibility card (green/yellow/red)
- gap_card: gap analysis action card with importance badges
- progress_tracker: 5-state journey progress indicator
- disclaimer_banner: medical disclaimer constant + spec

Services:
- state_manager: session state orchestration, forward-only journey transitions
- parlant_client: synchronous httpx wrapper for Parlant REST API

68 tests pass (37 component + 20 state + 11 client). Ruff clean.

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

app/components/disclaimer_banner.py

@@ -0,0 +1,17 @@
+"""Medical disclaimer banner — must appear on every page."""
+
+from __future__ import annotations
+
+DISCLAIMER_TEXT = (
+    "This tool provides information for educational purposes only and does not "
+    "constitute medical advice. Always consult your healthcare provider before "
+    "making decisions about clinical trial participation."
+)
+
+
+def render_disclaimer_spec() -> dict:
+    """Return a render spec for the disclaimer banner."""
+    return {
+        "type": "info",
+        "text": DISCLAIMER_TEXT,
+    }

app/components/file_uploader.py

@@ -0,0 +1,23 @@
+"""Multi-file PDF/image uploader component for clinical documents."""
+
+from __future__ import annotations
+
+_ACCEPTED_TYPES = ["pdf", "png", "jpg", "jpeg"]
+
+
+def render_file_uploader_spec() -> dict:
+    """Return a render spec for the clinical document uploader widget."""
+    return {
+        "label": "Upload clinical documents (PDF, images)",
+        "accepted_types": list(_ACCEPTED_TYPES),
+        "accept_multiple_files": True,
+        "help_text": "Upload clinic letters, pathology reports, lab results",
+        "widget_key": "clinical_docs_uploader",
+    }
+
+
+def format_file_info(filename: str, size_bytes: int) -> str:
+    """Format file name + size for display."""
+    if size_bytes >= 1_000_000:
+        return f"{filename} ({size_bytes / 1_000_000:.1f} MB)"
+    return f"{filename} ({size_bytes / 1_000:.1f} KB)"

app/components/gap_card.py

@@ -0,0 +1,25 @@
+"""Gap analysis action card component."""
+
+from __future__ import annotations
+
+from trialpath.models import GapItem
+
+_IMPORTANCE_COLORS = {
+    "high": "red",
+    "medium": "orange",
+    "low": "grey",
+}
+
+
+def render_gap_card(
+    gap: GapItem,
+    affected_trials: list[str] | None = None,
+) -> dict:
+    """Produce a render-spec dict for a single gap item."""
+    return {
+        "description": gap.description,
+        "recommended_action": gap.recommended_action,
+        "clinical_importance": gap.clinical_importance,
+        "importance_color": _IMPORTANCE_COLORS.get(gap.clinical_importance, "grey"),
+        "affected_trials": affected_trials or [],
+    }

app/components/profile_card.py

@@ -0,0 +1,44 @@
+"""PatientProfile display component — produces a render-spec dict."""
+
+from __future__ import annotations
+
+from trialpath.models import PatientProfile
+
+
+def render_profile_card(profile: PatientProfile) -> dict:
+    """Convert a PatientProfile into a flat dict suitable for UI rendering."""
+    return {
+        "patient_id": profile.patient_id,
+        "demographics": {
+            "age": profile.demographics.age,
+            "sex": profile.demographics.sex,
+        },
+        "diagnosis": (
+            {
+                "primary_condition": profile.diagnosis.primary_condition,
+                "histology": profile.diagnosis.histology,
+                "stage": profile.diagnosis.stage,
+            }
+            if profile.diagnosis
+            else None
+        ),
+        "performance_status": (
+            {
+                "scale": profile.performance_status.scale,
+                "value": profile.performance_status.value,
+            }
+            if profile.performance_status
+            else None
+        ),
+        "biomarkers": [
+            {"name": b.name, "result": b.result} for b in profile.biomarkers
+        ],
+        "treatments": [
+            {"drug_name": t.drug_name, "line": t.line} for t in profile.treatments
+        ],
+        "unknowns": [
+            {"field": u.field, "reason": u.reason, "importance": u.importance}
+            for u in profile.unknowns
+        ],
+        "has_minimum_prescreen_data": profile.has_minimum_prescreen_data(),
+    }

app/components/progress_tracker.py

@@ -0,0 +1,41 @@
+"""Journey state progress indicator component."""
+
+from __future__ import annotations
+
+from app.services.state_manager import JOURNEY_STATES
+
+_STEP_LABELS = {
+    "INGEST": "Upload Documents",
+    "PRESCREEN": "Review Profile",
+    "VALIDATE_TRIALS": "Trial Matching",
+    "GAP_FOLLOWUP": "Gap Analysis",
+    "SUMMARY": "Summary & Export",
+}
+
+
+def render_progress_tracker(current_state: str) -> dict:
+    """Produce a render-spec dict for the journey progress indicator."""
+    current_idx = (
+        JOURNEY_STATES.index(current_state)
+        if current_state in JOURNEY_STATES
+        else 0
+    )
+
+    steps = []
+    for i, state in enumerate(JOURNEY_STATES):
+        if i < current_idx:
+            status = "completed"
+        elif i == current_idx:
+            status = "current"
+        else:
+            status = "upcoming"
+        steps.append({
+            "state": state,
+            "label": _STEP_LABELS[state],
+            "status": status,
+        })
+
+    return {
+        "steps": steps,
+        "current_index": current_idx,
+    }

app/components/trial_card.py

@@ -0,0 +1,38 @@
+"""Traffic-light eligibility card component for a single trial."""
+
+from __future__ import annotations
+
+from trialpath.models import EligibilityLedger, TrialCandidate
+
+
+def render_trial_card(trial: TrialCandidate, ledger: EligibilityLedger) -> dict:
+    """Produce a render-spec dict combining trial info and eligibility assessment."""
+    return {
+        "nct_id": trial.nct_id,
+        "title": trial.title,
+        "phase": trial.phase,
+        "status": trial.status,
+        "conditions": trial.conditions,
+        "traffic_light": ledger.traffic_light,
+        "overall_assessment": ledger.overall_assessment.value,
+        "met_count": ledger.met_count,
+        "not_met_count": ledger.not_met_count,
+        "unknown_count": ledger.unknown_count,
+        "criteria": [
+            {
+                "criterion_id": c.criterion_id,
+                "type": c.type,
+                "text": c.text,
+                "decision": c.decision.value,
+            }
+            for c in ledger.criteria
+        ],
+        "gaps": [
+            {
+                "description": g.description,
+                "recommended_action": g.recommended_action,
+                "clinical_importance": g.clinical_importance,
+            }
+            for g in ledger.gaps
+        ],
+    }

app/services/parlant_client.py

@@ -0,0 +1,78 @@
+"""Parlant REST API client wrapper for TrialPath Streamlit frontend."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+_DEFAULT_BASE_URL = "http://localhost:8800"
+_DEFAULT_TIMEOUT = 65.0  # > long-poll wait_for_data default
+
+
+class ParlantClient:
+    """Synchronous wrapper around the Parlant REST API."""
+
+    def __init__(
+        self,
+        base_url: str = _DEFAULT_BASE_URL,
+        *,
+        transport: Optional[httpx.BaseTransport] = None,
+        timeout: float = _DEFAULT_TIMEOUT,
+    ) -> None:
+        self.base_url = base_url
+        self._http = httpx.Client(
+            base_url=base_url,
+            timeout=timeout,
+            transport=transport,
+        )
+
+    # ------ sessions ------
+
+    def create_session(
+        self, agent_id: str, customer_id: Optional[str] = None
+    ) -> str:
+        """Create a Parlant session and return the session_id."""
+        payload: dict = {"agent_id": agent_id}
+        if customer_id:
+            payload["customer_id"] = customer_id
+        resp = self._http.post("/sessions", json=payload)
+        resp.raise_for_status()
+        return resp.json()["session_id"]
+
+    def get_session_status(self, session_id: str) -> dict:
+        """Fetch session metadata."""
+        resp = self._http.get(f"/sessions/{session_id}")
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------ events ------
+
+    def send_message(self, session_id: str, message: str) -> dict:
+        """Send a customer message event to a session."""
+        resp = self._http.post(
+            f"/sessions/{session_id}/events",
+            json={"kind": "message", "source": "customer", "message": message},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    def poll_events(
+        self,
+        session_id: str,
+        min_offset: int = 0,
+        wait_seconds: int = 60,
+    ) -> list[dict]:
+        """Poll for new events starting from *min_offset*."""
+        resp = self._http.get(
+            f"/sessions/{session_id}/events",
+            params={"min_offset": min_offset, "wait_for_data": wait_seconds},
+        )
+        resp.raise_for_status()
+        return resp.json()
+
+    # ------ lifecycle ------
+
+    def close(self) -> None:
+        """Close the underlying HTTP client."""
+        self._http.close()

app/services/state_manager.py

@@ -0,0 +1,82 @@
+"""Session state orchestration for TrialPath Streamlit app."""
+
+import streamlit as st
+
+JOURNEY_STATES = ["INGEST", "PRESCREEN", "VALIDATE_TRIALS", "GAP_FOLLOWUP", "SUMMARY"]
+
+_DEFAULTS = {
+    "journey_state": "INGEST",
+    "parlant_session_id": None,
+    "parlant_agent_id": None,
+    "patient_profile": None,
+    "uploaded_files": [],
+    "search_anchors": None,
+    "trial_candidates": [],
+    "eligibility_ledger": [],
+    "last_event_offset": 0,
+}
+
+
+def init_session_state() -> None:
+    """Initialize all session state variables with defaults.
+
+    Does not overwrite values that already exist.
+    """
+    for key, default_value in _DEFAULTS.items():
+        if key not in st.session_state:
+            st.session_state[key] = default_value
+
+
+def get_current_journey_state() -> str:
+    """Return the current journey state, defaulting to INGEST."""
+    return st.session_state.get("journey_state", "INGEST")
+
+
+def advance_journey(target_state: str) -> None:
+    """Advance the journey to *target_state*.
+
+    Raises ValueError if the target is invalid, the same as current, or backward.
+    """
+    if target_state not in JOURNEY_STATES:
+        raise ValueError(f"Invalid journey state: {target_state}")
+
+    current = st.session_state.get("journey_state", "INGEST")
+    current_idx = JOURNEY_STATES.index(current)
+    target_idx = JOURNEY_STATES.index(target_state)
+
+    if target_idx == current_idx:
+        raise ValueError(f"Already at same state: {target_state}")
+    if target_idx < current_idx:
+        raise ValueError(f"Cannot move backward from {current} to {target_state}")
+
+    st.session_state["journey_state"] = target_state
+
+
+def can_advance_to(target_state: str) -> bool:
+    """Check whether prerequisites are met to advance to *target_state*."""
+    if target_state not in JOURNEY_STATES:
+        return False
+
+    current = st.session_state.get("journey_state", "INGEST")
+    current_idx = JOURNEY_STATES.index(current)
+    target_idx = JOURNEY_STATES.index(target_state)
+
+    if target_idx <= current_idx:
+        return False
+
+    # Prerequisites: every state beyond INGEST requires a patient_profile
+    if target_idx >= JOURNEY_STATES.index("PRESCREEN"):
+        if not st.session_state.get("patient_profile"):
+            return False
+
+    # GAP_FOLLOWUP and beyond require trial_candidates
+    if target_idx >= JOURNEY_STATES.index("GAP_FOLLOWUP"):
+        if not st.session_state.get("trial_candidates"):
+            return False
+
+    # SUMMARY requires eligibility_ledger
+    if target_idx >= JOURNEY_STATES.index("SUMMARY"):
+        if not st.session_state.get("eligibility_ledger"):
+            return False
+
+    return True

app/tests/test_components.py

@@ -0,0 +1,473 @@
+"""Tests for app/components/ — Streamlit UI components.
+
+Each component is a pure function that takes data and returns a render-spec dict
+(not actual Streamlit widgets) so we can test without a running Streamlit app.
+
+Components:
+  1. file_uploader   - render_file_uploader_spec
+  2. profile_card    - render_profile_card
+  3. trial_card      - render_trial_card
+  4. gap_card        - render_gap_card
+  5. progress_tracker - render_progress_tracker
+  6. disclaimer_banner - DISCLAIMER_TEXT, render_disclaimer_spec
+"""
+
+import pytest
+
+from trialpath.models import (
+    Biomarker,
+    CriterionAssessment,
+    CriterionDecision,
+    Demographics,
+    Diagnosis,
+    EligibilityLedger,
+    GapItem,
+    OverallAssessment,
+    PatientProfile,
+    PerformanceStatus,
+    Treatment,
+    TrialCandidate,
+    UnknownField,
+)
+
+# ---------------------------------------------------------------------------
+# Fixtures — reusable model instances
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def sample_profile():
+    return PatientProfile(
+        patient_id="P001",
+        demographics=Demographics(age=62, sex="Female"),
+        diagnosis=Diagnosis(
+            primary_condition="Non-Small Cell Lung Cancer",
+            histology="adenocarcinoma",
+            stage="IIIB",
+        ),
+        performance_status=PerformanceStatus(scale="ECOG", value=1),
+        biomarkers=[
+            Biomarker(name="EGFR", result="Exon 19 deletion"),
+            Biomarker(name="ALK", result="Negative"),
+            Biomarker(name="PD-L1", result="45%"),
+        ],
+        treatments=[
+            Treatment(drug_name="Carboplatin", line=1),
+            Treatment(drug_name="Pemetrexed", line=1),
+        ],
+        unknowns=[
+            UnknownField(field="KRAS", reason="Not in records", importance="high"),
+            UnknownField(field="Brain MRI", reason="Not available", importance="medium"),
+        ],
+    )
+
+
+@pytest.fixture
+def sample_trial():
+    return TrialCandidate(
+        nct_id="NCT04000001",
+        title="KEYNOTE-999: Pembrolizumab + Chemo for NSCLC",
+        conditions=["NSCLC"],
+        phase="Phase 3",
+        status="Recruiting",
+        fingerprint_text="Pembrolizumab combination therapy advanced NSCLC",
+    )
+
+
+@pytest.fixture
+def sample_ledger():
+    return EligibilityLedger(
+        patient_id="P001",
+        nct_id="NCT04000001",
+        overall_assessment=OverallAssessment.UNCERTAIN,
+        criteria=[
+            CriterionAssessment(
+                criterion_id="inc_1",
+                type="inclusion",
+                text="Confirmed NSCLC diagnosis",
+                decision=CriterionDecision.MET,
+            ),
+            CriterionAssessment(
+                criterion_id="inc_2",
+                type="inclusion",
+                text="ECOG 0-1",
+                decision=CriterionDecision.MET,
+            ),
+            CriterionAssessment(
+                criterion_id="inc_3",
+                type="inclusion",
+                text="PD-L1 >= 50%",
+                decision=CriterionDecision.NOT_MET,
+            ),
+            CriterionAssessment(
+                criterion_id="exc_1",
+                type="exclusion",
+                text="No prior immunotherapy",
+                decision=CriterionDecision.UNKNOWN,
+            ),
+        ],
+        gaps=[
+            GapItem(
+                description="Brain MRI results needed",
+                recommended_action="Upload brain MRI report",
+                clinical_importance="high",
+            ),
+        ],
+    )
+
+
+# ===========================================================================
+# 1. file_uploader
+# ===========================================================================
+
+
+class TestFileUploader:
+    def test_spec_has_accepted_types(self):
+        from app.components.file_uploader import render_file_uploader_spec
+
+        spec = render_file_uploader_spec()
+        assert "pdf" in spec["accepted_types"]
+        assert "png" in spec["accepted_types"]
+        assert "jpg" in spec["accepted_types"]
+        assert "jpeg" in spec["accepted_types"]
+
+    def test_spec_allows_multiple_files(self):
+        from app.components.file_uploader import render_file_uploader_spec
+
+        spec = render_file_uploader_spec()
+        assert spec["accept_multiple_files"] is True
+
+    def test_spec_has_label(self):
+        from app.components.file_uploader import render_file_uploader_spec
+
+        spec = render_file_uploader_spec()
+        assert "label" in spec
+        assert len(spec["label"]) > 0
+
+    def test_format_file_info(self):
+        from app.components.file_uploader import format_file_info
+
+        result = format_file_info("report.pdf", 245_000)
+        assert "report.pdf" in result
+        assert "KB" in result
+
+    def test_format_file_info_large_file(self):
+        from app.components.file_uploader import format_file_info
+
+        result = format_file_info("scan.pdf", 2_500_000)
+        assert "MB" in result
+
+
+# ===========================================================================
+# 2. profile_card
+# ===========================================================================
+
+
+class TestProfileCard:
+    def test_renders_demographics(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert card["demographics"]["age"] == 62
+        assert card["demographics"]["sex"] == "Female"
+
+    def test_renders_diagnosis(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert "NSCLC" in card["diagnosis"]["primary_condition"] or \
+               "Non-Small Cell" in card["diagnosis"]["primary_condition"]
+        assert card["diagnosis"]["stage"] == "IIIB"
+        assert card["diagnosis"]["histology"] == "adenocarcinoma"
+
+    def test_renders_biomarkers(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert len(card["biomarkers"]) == 3
+        names = [b["name"] for b in card["biomarkers"]]
+        assert "EGFR" in names
+        assert "PD-L1" in names
+
+    def test_renders_treatments(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert len(card["treatments"]) == 2
+        assert card["treatments"][0]["drug_name"] == "Carboplatin"
+
+    def test_renders_unknowns(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert len(card["unknowns"]) == 2
+        fields = [u["field"] for u in card["unknowns"]]
+        assert "KRAS" in fields
+        assert "Brain MRI" in fields
+
+    def test_renders_performance_status(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert card["performance_status"]["scale"] == "ECOG"
+        assert card["performance_status"]["value"] == 1
+
+    def test_handles_none_diagnosis(self):
+        from app.components.profile_card import render_profile_card
+
+        profile = PatientProfile(patient_id="P002")
+        card = render_profile_card(profile)
+        assert card["diagnosis"] is None
+
+    def test_handles_empty_biomarkers(self):
+        from app.components.profile_card import render_profile_card
+
+        profile = PatientProfile(patient_id="P003")
+        card = render_profile_card(profile)
+        assert card["biomarkers"] == []
+
+    def test_has_minimum_prescreen_flag(self, sample_profile):
+        from app.components.profile_card import render_profile_card
+
+        card = render_profile_card(sample_profile)
+        assert card["has_minimum_prescreen_data"] is True
+
+    def test_has_minimum_prescreen_flag_false(self):
+        from app.components.profile_card import render_profile_card
+
+        profile = PatientProfile(patient_id="P004")
+        card = render_profile_card(profile)
+        assert card["has_minimum_prescreen_data"] is False
+
+
+# ===========================================================================
+# 3. trial_card
+# ===========================================================================
+
+
+class TestTrialCard:
+    def test_renders_basic_info(self, sample_trial, sample_ledger):
+        from app.components.trial_card import render_trial_card
+
+        card = render_trial_card(sample_trial, sample_ledger)
+        assert card["nct_id"] == "NCT04000001"
+        assert "KEYNOTE" in card["title"]
+        assert card["phase"] == "Phase 3"
+        assert card["status"] == "Recruiting"
+
+    def test_renders_traffic_light(self, sample_trial, sample_ledger):
+        from app.components.trial_card import render_trial_card
+
+        card = render_trial_card(sample_trial, sample_ledger)
+        assert card["traffic_light"] == "yellow"
+
+    def test_renders_criteria_counts(self, sample_trial, sample_ledger):
+        from app.components.trial_card import render_trial_card
+
+        card = render_trial_card(sample_trial, sample_ledger)
+        assert card["met_count"] == 2
+        assert card["not_met_count"] == 1
+        assert card["unknown_count"] == 1
+
+    def test_renders_criteria_list(self, sample_trial, sample_ledger):
+        from app.components.trial_card import render_trial_card
+
+        card = render_trial_card(sample_trial, sample_ledger)
+        assert len(card["criteria"]) == 4
+        first = card["criteria"][0]
+        assert "criterion_id" in first
+        assert "text" in first
+        assert "decision" in first
+
+    def test_renders_overall_assessment(self, sample_trial, sample_ledger):
+        from app.components.trial_card import render_trial_card
+
+        card = render_trial_card(sample_trial, sample_ledger)
+        assert card["overall_assessment"] == "uncertain"
+
+    def test_green_traffic_light(self, sample_trial):
+        from app.components.trial_card import render_trial_card
+
+        ledger = EligibilityLedger(
+            patient_id="P001",
+            nct_id="NCT04000001",
+            overall_assessment=OverallAssessment.LIKELY_ELIGIBLE,
+            criteria=[
+                CriterionAssessment(
+                    criterion_id="inc_1", type="inclusion",
+                    text="Has NSCLC", decision=CriterionDecision.MET,
+                ),
+            ],
+        )
+        card = render_trial_card(sample_trial, ledger)
+        assert card["traffic_light"] == "green"
+
+    def test_red_traffic_light(self, sample_trial):
+        from app.components.trial_card import render_trial_card
+
+        ledger = EligibilityLedger(
+            patient_id="P001",
+            nct_id="NCT04000001",
+            overall_assessment=OverallAssessment.LIKELY_INELIGIBLE,
+            criteria=[
+                CriterionAssessment(
+                    criterion_id="inc_1", type="inclusion",
+                    text="Has NSCLC", decision=CriterionDecision.NOT_MET,
+                ),
+            ],
+        )
+        card = render_trial_card(sample_trial, ledger)
+        assert card["traffic_light"] == "red"
+
+    def test_gaps_included(self, sample_trial, sample_ledger):
+        from app.components.trial_card import render_trial_card
+
+        card = render_trial_card(sample_trial, sample_ledger)
+        assert len(card["gaps"]) == 1
+        assert card["gaps"][0]["description"] == "Brain MRI results needed"
+
+
+# ===========================================================================
+# 4. gap_card
+# ===========================================================================
+
+
+class TestGapCard:
+    def test_renders_single_gap(self):
+        from app.components.gap_card import render_gap_card
+
+        gap = GapItem(
+            description="Brain MRI results needed",
+            recommended_action="Upload brain MRI report",
+            clinical_importance="high",
+        )
+        card = render_gap_card(gap, affected_trials=["NCT04000001", "NCT04000003"])
+        assert card["description"] == "Brain MRI results needed"
+        assert card["recommended_action"] == "Upload brain MRI report"
+        assert card["clinical_importance"] == "high"
+        assert len(card["affected_trials"]) == 2
+
+    def test_renders_gap_without_affected_trials(self):
+        from app.components.gap_card import render_gap_card
+
+        gap = GapItem(
+            description="KRAS mutation status",
+            recommended_action="Request test from oncologist",
+            clinical_importance="medium",
+        )
+        card = render_gap_card(gap)
+        assert card["affected_trials"] == []
+
+    def test_importance_badge(self):
+        from app.components.gap_card import render_gap_card
+
+        gap = GapItem(
+            description="Test gap",
+            recommended_action="Do something",
+            clinical_importance="high",
+        )
+        card = render_gap_card(gap)
+        assert card["importance_color"] == "red"
+
+    def test_importance_badge_medium(self):
+        from app.components.gap_card import render_gap_card
+
+        gap = GapItem(
+            description="Test gap",
+            recommended_action="Do something",
+            clinical_importance="medium",
+        )
+        card = render_gap_card(gap)
+        assert card["importance_color"] == "orange"
+
+    def test_importance_badge_low(self):
+        from app.components.gap_card import render_gap_card
+
+        gap = GapItem(
+            description="Test gap",
+            recommended_action="Do something",
+            clinical_importance="low",
+        )
+        card = render_gap_card(gap)
+        assert card["importance_color"] == "grey"
+
+
+# ===========================================================================
+# 5. progress_tracker
+# ===========================================================================
+
+
+class TestProgressTracker:
+    def test_renders_all_states(self):
+        from app.components.progress_tracker import render_progress_tracker
+
+        spec = render_progress_tracker("INGEST")
+        assert len(spec["steps"]) == 5
+
+    def test_ingest_is_current(self):
+        from app.components.progress_tracker import render_progress_tracker
+
+        spec = render_progress_tracker("INGEST")
+        steps = spec["steps"]
+        assert steps[0]["status"] == "current"
+        assert steps[1]["status"] == "upcoming"
+
+    def test_middle_state(self):
+        from app.components.progress_tracker import render_progress_tracker
+
+        spec = render_progress_tracker("VALIDATE_TRIALS")
+        steps = spec["steps"]
+        assert steps[0]["status"] == "completed"
+        assert steps[1]["status"] == "completed"
+        assert steps[2]["status"] == "current"
+        assert steps[3]["status"] == "upcoming"
+        assert steps[4]["status"] == "upcoming"
+
+    def test_summary_state(self):
+        from app.components.progress_tracker import render_progress_tracker
+
+        spec = render_progress_tracker("SUMMARY")
+        steps = spec["steps"]
+        for i in range(4):
+            assert steps[i]["status"] == "completed"
+        assert steps[4]["status"] == "current"
+
+    def test_step_labels(self):
+        from app.components.progress_tracker import render_progress_tracker
+
+        spec = render_progress_tracker("INGEST")
+        labels = [s["label"] for s in spec["steps"]]
+        assert "Upload" in labels[0]
+        assert "Summary" in labels[4] or "Export" in labels[4]
+
+    def test_current_index(self):
+        from app.components.progress_tracker import render_progress_tracker
+
+        spec = render_progress_tracker("GAP_FOLLOWUP")
+        assert spec["current_index"] == 3
+
+
+# ===========================================================================
+# 6. disclaimer_banner
+# ===========================================================================
+
+
+class TestDisclaimerBanner:
+    def test_disclaimer_text_content(self):
+        from app.components.disclaimer_banner import DISCLAIMER_TEXT
+
+        text_lower = DISCLAIMER_TEXT.lower()
+        assert "information" in text_lower or "educational" in text_lower
+        assert "medical advice" in text_lower
+
+    def test_disclaimer_spec(self):
+        from app.components.disclaimer_banner import render_disclaimer_spec
+
+        spec = render_disclaimer_spec()
+        assert spec["type"] == "info"
+        assert len(spec["text"]) > 0
+
+    def test_disclaimer_not_empty(self):
+        from app.components.disclaimer_banner import DISCLAIMER_TEXT
+
+        assert len(DISCLAIMER_TEXT) > 20