Replace clustering with Candidate Analysis tab

core/analysis/candidate_score.py

@@ -0,0 +1,150 @@
+"""
+Candidate objective scoring for mRNA design.
+
+Condenses a full AnalysisReport into the four objectives an mRNA designer
+trades off, each on a 0–100 scale where **higher is better**:
+
+  - **Expression**       — translation potential (CAI, Kozak strength)
+  - **Stability**        — predicted durability (GC balance, structure, homopolymers)
+  - **Immunogenicity**   — *inverse* of innate-immune risk (uridine content)
+  - **Manufacturability**— clean synthesis/IVT (restriction sites, homopolymers, GC extremes)
+
+These are transparent heuristics, not trained predictors — they exist to rank and
+shortlist candidates from the metrics already computed. The function reads the
+report by duck typing and degrades gracefully when a metric is unavailable (e.g.
+ViennaRNA not installed → structure ignored rather than penalised).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict
+
+
+def _clamp(x: float) -> float:
+    return max(0.0, min(100.0, x))
+
+
+@dataclass
+class ObjectiveScores:
+    expression: float
+    stability: float
+    immunogenicity: float
+    manufacturability: float
+    overall: float
+    details: Dict[str, str] = field(default_factory=dict)
+
+    def as_row(self) -> Dict[str, float]:
+        return {
+            "Expression": round(self.expression),
+            "Stability": round(self.stability),
+            "Immunogenicity": round(self.immunogenicity),
+            "Manufacturability": round(self.manufacturability),
+            "Overall": round(self.overall),
+        }
+
+
+# objective -> weight in the overall score
+OBJECTIVE_WEIGHTS = {
+    "expression": 0.30,
+    "stability": 0.25,
+    "immunogenicity": 0.20,
+    "manufacturability": 0.25,
+}
+
+_KOZAK_SCORE = {"strong": 100.0, "adequate": 70.0, "weak": 35.0}
+
+
+def _liability_categories(report: Any) -> Dict[str, str]:
+    """Map liability category -> worst severity seen (from report.liability.flags)."""
+    out: Dict[str, str] = {}
+    lia = getattr(report, "liability", None)
+    order = {"critical": 0, "warning": 1, "info": 2}
+    for f in getattr(lia, "flags", []) or []:
+        cur = out.get(f.category)
+        if cur is None or order.get(f.severity, 9) < order.get(cur, 9):
+            out[f.category] = f.severity
+    return out
+
+
+def score_objectives(report: Any) -> ObjectiveScores:
+    """Compute the four 0–100 objective scores from an analysis report."""
+    details: Dict[str, str] = {}
+    cats = _liability_categories(report)
+
+    # ── Expression ────────────────────────────────────────────────────────────
+    cai = getattr(report, "cai", None)
+    cai_score = cai * 100.0 if cai is not None else 60.0
+    kz = getattr(report, "kozak", None)
+    kz_strength = getattr(kz, "strength", None)
+    kozak_score = _KOZAK_SCORE.get(kz_strength, 60.0)
+    expression = _clamp(0.6 * cai_score + 0.4 * kozak_score)
+    details["expression"] = (
+        f"CAI {('%.2f' % cai) if cai is not None else 'n/a'}, "
+        f"Kozak {kz_strength or 'n/a'}"
+    )
+
+    # ── Stability ─────────────────────────────────────────────────────────────
+    gc = getattr(report, "gc_percent_global", None)
+    if gc:
+        # full marks in 50–60%, falling off outside
+        gc_score = 100.0 - 3.0 * max(0.0, abs(gc - 55.0) - 5.0)
+    else:
+        gc_score = 60.0
+    hp_sev = cats.get("Homopolymer")
+    hp_pen = 25.0 if hp_sev == "critical" else 10.0 if hp_sev == "warning" else 0.0
+    struct = getattr(report, "structure", None)
+    struct_note = ""
+    if struct is not None and not getattr(struct, "is_stub", True):
+        length = max(len(getattr(struct, "sequence", "") or ""), 1)
+        per_nt = getattr(struct, "mfe", 0.0) / length
+        # moderate structure is stabilising; reward down to ~-0.4/nt, then taper
+        struct_bonus = max(-10.0, min(10.0, (-per_nt) * 25.0 - 5.0))
+        gc_score += struct_bonus
+        struct_note = f", MFE {per_nt:.2f}/nt"
+    stability = _clamp(gc_score - hp_pen)
+    details["stability"] = f"GC {gc:.0f}%" if gc else "GC n/a"
+    details["stability"] += struct_note + (f", homopolymer {hp_sev}" if hp_sev else "")
+
+    # ── Immunogenicity (higher = less immunogenic) ────────────────────────────
+    uri = getattr(report, "uridine", None)
+    u_pct = getattr(uri, "u_percent", None)
+    n_stretch = len(getattr(uri, "high_u_stretches", []) or [])
+    if u_pct is None:
+        immunogenicity = 60.0
+        details["immunogenicity"] = "uridine n/a"
+    else:
+        base = 100.0 - max(0.0, u_pct - 20.0) * 3.0
+        immunogenicity = _clamp(base - 8.0 * n_stretch)
+        details["immunogenicity"] = f"U {u_pct:.0f}%, {n_stretch} high-U stretch(es)"
+
+    # ── Manufacturability ─────────────────────────────────────────────────────
+    manuf = 100.0
+    n_re = len(getattr(report, "restriction_enzymes_present", []) or [])
+    manuf -= min(36.0, 12.0 * n_re)
+    if hp_sev == "critical":
+        manuf -= 25.0
+    elif hp_sev == "warning":
+        manuf -= 12.0
+    gc_sev = cats.get("GC")
+    manuf -= 20.0 if gc_sev == "critical" else 8.0 if gc_sev == "warning" else 0.0
+    if cats.get("Motif"):
+        manuf -= 5.0
+    manufacturability = _clamp(manuf)
+    details["manufacturability"] = (
+        f"{n_re} restriction site(s)"
+        + (f", homopolymer {hp_sev}" if hp_sev else "")
+        + (f", GC {gc_sev}" if gc_sev else "")
+    )
+
+    overall = (
+        OBJECTIVE_WEIGHTS["expression"] * expression
+        + OBJECTIVE_WEIGHTS["stability"] * stability
+        + OBJECTIVE_WEIGHTS["immunogenicity"] * immunogenicity
+        + OBJECTIVE_WEIGHTS["manufacturability"] * manufacturability
+    )
+
+    return ObjectiveScores(
+        expression=expression, stability=stability,
+        immunogenicity=immunogenicity, manufacturability=manufacturability,
+        overall=_clamp(overall), details=details,
+    )

demo/DEMO_SCRIPT.md

@@ -1,54 +1,93 @@
-# mRNA Design Studio — Demo Script (one page)
+# mRNA Design Studio — Demo Script (full run-through)
 
 **Live app:** https://offtargeteffect-mrna-design-studio.hf.space
-**Login:** username `admin` · password `vOAMljsXrzCemLZK4A38` *(or remove the password for a smoother live demo — see Prep)*
-**Open in its own browser tab** — not the Hugging Face embedded preview (that loops on login).
+**Login:** username `admin` · password `vOAMljsXrzCemLZK4A38`
+**Open in its own browser tab** — NOT the Hugging Face embedded preview (that loops on login).
 
 ---
 
-## Prep (do 5 min before)
-- [ ] Visit the URL to **wake the Space** (free tier sleeps; first load is slow).
-- [ ] Have the sample file ready to drag in: `demo/demo_sequences_extended.csv` (14 constructs).
-- [ ] *(Optional)* For the live database demo, have the Postgres connection details on a sticky note.
-- [ ] *(Optional)* Remove the login: Space → Settings → secrets → delete `MRNA_STUDIO_PASSWORD` → app opens with no login.
+## 0. Prep (5 min before)
+- [ ] Visit the URL to **wake the Space** (free tier sleeps; first load is slow). Log in once.
+- [ ] Have the CSV ready to drag in: `demo/demo_sequences_extended.csv` (14 constructs).
+- [ ] (Optional) Postgres path — keep these handy for the Import Data → PostgreSQL form:
+      host `ep-blue-flower-abs3fw0x.eu-west-2.aws.neon.tech` · port `5432` · db `neondb`
+      · user `neondb_owner` · pass `npg_oJzU6SfIK7yg` · table `mrna_sequences`
+- [ ] (Optional) For a no-login live demo: delete the `MRNA_STUDIO_PASSWORD` secret in Space settings.
+
+## The pitch (say this first, ~30s)
+"This is a workbench that takes mRNA sequence data from import all the way to a
+QC'd, scored, assembled construct — in one no-code UI. I'll walk the funnel:
+**import → analyze & flag liabilities → compare candidates → score → track runs → assemble.**"
 
 ---
 
-## The story — follow the sidebar top to bottom (~8–10 min)
+## 1. Import Data  (~90s)
+- **[Click]** the **Import Data** tab.
+- **CSV path:** drag `demo_sequences_extended.csv` onto the uploader → it **auto-suggests column mappings** (gene_name, cds, UTRs…) → **Import Records**.
+- **OR Postgres path:** choose **PostgreSQL**, paste the connection details above, **Connect** → pick table `mrna_sequences` → **Preview** → **Import Records**.
+- **[Say]** "It ingests messy real-world tables — component-based *or* monolithic — and maps them to a structured mRNA model automatically."
 
-**1. Import Data  (90s)** — "It ingests real-world sequence tables and structures them automatically."
-- Drag `demo/demo_sequences_extended.csv` onto the CSV uploader.
-- Show the **auto-suggested column mapping** (gene_name, cds, UTRs, …).
-- Click **Import Records** → 14 sequences land in the Worklist.
-- *Or* demo the **PostgreSQL** path: pick PostgreSQL, paste the connection details, Connect → select `mrna_sequences` → Preview → Import.
+## 2. Worklist — analysis + liability/QC  (~3 min)  ★ NEW
+- **[Click]** the **Worklist** tab → your 14 sequences are listed.
+- **[Click]** the **Analysis** dropdown → **Base Analysis** → **Run**.
+- **[Show]** the new columns populate: **GC%, CAI, Homopolymers, Restriction Sites**, and the new **QC** (`Pass/Review · score`) and **Liabilities** count.
+- **[Click] a row** (e.g. `eGFP-hBG-HEK`) → a **Liability / QC breakdown** appears below the table:
+  - a **QC scorecard** (0–100 score, Pass/Review/Fail verdict, severity counts),
+  - a ranked list of **flags** with severity, detail, location, and a recommendation
+    (e.g. internal restriction site, uORF in the 5′UTR, elevated uridine).
+- **[Say]** "This is the developability/liability overlay — every candidate gets a QC
+  score and specific, actionable flags, right on the candidate list."
 
-**2. Worklist → Analyze  (2 min)** — "Instant QC across the whole panel."
-- Select all → **Analyze**.
-- Point out **GC%**, **CAI** (codon adaptation), **homopolymer** runs (the poly-A tails!), **restriction sites**.
-- Note the contrast: component-based vs monolithic records both analyze cleanly.
+## 3. Candidate Analysis  (~3 min)  ★ NEW
+- **[Click]** the **Candidate Analysis** tab.
+- **[Show]** the **Comparison scorecard** — every candidate scored 0–100 on the four mRNA
+  objectives (**Expression, Stability, Immunogenicity, Manufacturability**) + an **Overall**,
+  ranked, with a ★ **top-N shortlist** (drag the slider).
+- **[Say]** "This is the design trade-off view — a candidate can win on expression but lose
+  on immunogenicity. You rank and shortlist on the criteria that actually matter for mRNA."
+- **[Use]** the **Inspect candidate** dropdown → the **Sequence / structure map** shows that
+  molecule's region bands (5′UTR/CDS/3′UTR/polyA), GC profile, and markers for restriction
+  sites / homopolymers / liability motifs — i.e. *where* the problems are — plus its full
+  liability scorecard.
+- **[Say]** "And drill into any candidate to see exactly where its features and liabilities sit."
 
-**3. Model Repository  (1 min)** — "Pluggable scoring — local models or remote APIs."
-- Show the two built-in scorers: **mRNA Stability Scorer** and **RNA Structure Scorer**.
-- Mention you can register a remote API endpoint too.
+## 4. Model Repository  (~1 min)
+- **[Click]** the **Model Repository** tab → browse models; note each has a **version**.
+- **[Show]** the two built-in scorers: **mRNA Stability Scorer** and **RNA Structure Scorer**
+  (and that you can register a local Python model or a remote API endpoint).
 
-**4. Worklist → Score & Export  (2 min)** — "Rank candidates, hand off to the lab."
-- Back on the Worklist, **Score** with a loaded model → **sort by score**.
-- **Export CSV** of the ranked panel.
+## 5. Score the worklist  (~1 min)
+- **[Click]** back to **Worklist** → **Analysis** dropdown → pick a model
+  (e.g. **mRNA Stability Scorer**) → **Run**.
+- **[Show]** a score column appears; sort by it to rank candidates. **Export CSV** for the lab.
+- (Run a *second* model too — e.g. RNA Structure Scorer — so you have two runs to compare next.)
 
-**5. Parts Workshop  (1 min)** — "A reusable parts library."
-- Browse 5'UTR / Kozak / CDS / 3'UTR / poly-A parts; compose a construct.
+## 6. Experiments — run history + comparison  (~2 min)  ★ NEW
+- **[Click]** the **Experiments** tab.
+- **[Show]** **Registered models** (with versions) and a **Run history** table — every scoring
+  run is logged with version, N, mean/range of scores, and timestamp.
+- **[Use]** the **Compare runs** dropdowns (Run A baseline → Run B) → a summary shows
+  **mean Δ, ▲ improved / ▼ worsened** counts and a per-sequence delta table.
+- **[Say]** "This is the lifecycle layer: track every scoring run and compare versions or
+  scorers to see exactly which candidates moved and by how much."
 
-**6. Assemble Plasmid → Generate Sequences  (2 min)** — "Close the loop."
-- Pick the **pUC19-MCS** backbone, run **QC**, export the assembled construct.
-- In **Generate Sequences**, produce a codon-optimized variant.
+## 7. Parts Workshop → Assemble → Generate  (~2 min)
+- **Parts Workshop:** browse reusable parts (5′UTR / Kozak / CDS / 3′UTR / poly-A) and compose.
+- **Assemble Plasmid:** pick the **pUC19-MCS** backbone, run **QC**, export the assembled construct.
+- **Generate Sequences:** produce a codon-optimized variant.
+- **[Say]** "Close the loop — assemble into a plasmid with QC, or generate optimized variants."
 
 ---
 
-## If you have only 3 minutes
-Import `demo/demo_sequences_extended.csv` → **Analyze** → **Score** → **Export.**
-That's the whole value: ingest → analyze → score → export.
+## If you only have 3 minutes
+Import `demo_sequences_extended.csv` → **Worklist** Run base analysis → click a row for the
+**liability breakdown** → **Candidate Analysis** scorecard + map → score a model → **Experiments** compare.
+That hits the four differentiators (QC liability, candidate comparison, scoring, experiment tracking).
 
 ## Likely questions
-- *"Where does the data live?"* → CSV/Excel upload or a PostgreSQL connection you provide.
-- *"Can I use my own models?"* → Yes — register a local Python model or a remote API endpoint.
-- *"Is it hosted?"* → Runs on Hugging Face Spaces (Docker); also runs locally with `make run`.
+- *"Where does data live?"* → CSV/Excel upload or a PostgreSQL connection you provide.
+- *"Custom models?"* → register a local Python model or a remote API endpoint; runs are tracked.
+- *"How is this like/unlike ENPICOM?"* → same no-code, data+AI philosophy; this is the
+  design/build + light-liability side (mRNA), not NGS-scale repertoire discovery. See
+  `demo/ENPICOM_gap_analysis.md`.
+- *"Is it hosted?"* → runs on Hugging Face Spaces (Docker); also runs locally with `make run`.

tests/test_candidate_score.py

@@ -0,0 +1,78 @@
+"""Tests for candidate objective scoring."""
+from types import SimpleNamespace
+
+import pytest
+
+from core.analysis.candidate_score import score_objectives, OBJECTIVE_WEIGHTS
+
+
+def _report(cai=0.8, kozak="strong", gc=55.0, u_pct=20.0, stretches=0,
+            enzymes=None, flags=None, structure_stub=True):
+    return SimpleNamespace(
+        cai=cai,
+        kozak=SimpleNamespace(strength=kozak) if kozak else None,
+        gc_percent_global=gc,
+        uridine=SimpleNamespace(u_percent=u_pct, high_u_stretches=[(0, 1, 1)] * stretches),
+        restriction_enzymes_present=enzymes or [],
+        structure=SimpleNamespace(is_stub=structure_stub, mfe=0.0, sequence=""),
+        liability=SimpleNamespace(flags=flags or []),
+    )
+
+
+def _flag(category, severity):
+    return SimpleNamespace(category=category, severity=severity)
+
+
+class TestObjectiveScores:
+    def test_ideal_candidate_scores_high(self):
+        s = score_objectives(_report())
+        assert s.expression > 80
+        assert s.immunogenicity > 90      # low uridine
+        assert s.manufacturability == 100  # no liabilities
+        assert s.overall > 80
+
+    def test_weights_sum_to_one(self):
+        assert abs(sum(OBJECTIVE_WEIGHTS.values()) - 1.0) < 1e-9
+
+    def test_overall_is_weighted_mean(self):
+        s = score_objectives(_report())
+        expected = (
+            OBJECTIVE_WEIGHTS["expression"] * s.expression
+            + OBJECTIVE_WEIGHTS["stability"] * s.stability
+            + OBJECTIVE_WEIGHTS["immunogenicity"] * s.immunogenicity
+            + OBJECTIVE_WEIGHTS["manufacturability"] * s.manufacturability
+        )
+        assert s.overall == pytest.approx(expected, abs=0.5)
+
+    def test_low_cai_and_weak_kozak_drop_expression(self):
+        hi = score_objectives(_report(cai=0.9, kozak="strong"))
+        lo = score_objectives(_report(cai=0.3, kozak="weak"))
+        assert lo.expression < hi.expression
+
+    def test_high_uridine_lowers_immunogenicity_score(self):
+        clean = score_objectives(_report(u_pct=18.0))
+        hot = score_objectives(_report(u_pct=45.0, stretches=2))
+        assert hot.immunogenicity < clean.immunogenicity
+
+    def test_restriction_sites_lower_manufacturability(self):
+        s = score_objectives(_report(enzymes=["EcoRI", "BamHI"]))
+        assert s.manufacturability < 100
+
+    def test_homopolymer_flag_hits_stability_and_manufacturability(self):
+        s = score_objectives(_report(flags=[_flag("Homopolymer", "critical")]))
+        clean = score_objectives(_report())
+        assert s.stability < clean.stability
+        assert s.manufacturability < clean.manufacturability
+
+    def test_missing_metrics_are_neutral_not_zero(self):
+        s = score_objectives(SimpleNamespace())  # empty report
+        for v in (s.expression, s.stability, s.immunogenicity, s.manufacturability):
+            assert 0 < v <= 100
+
+    def test_scores_bounded_0_100(self):
+        s = score_objectives(_report(cai=0.0, kozak="weak", gc=10.0, u_pct=90.0,
+                                     stretches=10, enzymes=["A", "B", "C", "D"],
+                                     flags=[_flag("Homopolymer", "critical"),
+                                            _flag("GC", "critical"), _flag("Motif", "warning")]))
+        for v in (s.expression, s.stability, s.immunogenicity, s.manufacturability, s.overall):
+            assert 0 <= v <= 100

ui/app.py

@@ -40,7 +40,7 @@ from ui.components.plasmid_view import PlasmidView
 from ui.components.model_repository import ModelRepositoryPanel
 from ui.components.plasmid_assembly import PlasmidAssemblyPanel
 from ui.components.generate_sequences import GenerateSequencesPanel
-from ui.components.cluster_view import ClusterView
+from ui.components.candidate_view import CandidateView
 from ui.components.experiment_view import ExperimentView
 
 
@@ -152,13 +152,13 @@ _TAB_NAMES = [
     "Import Data",
     "Model Repository",
     "Worklist",
-    "Cluster & Tree",
+    "Candidate Analysis",
     "Experiments",
     "Parts Workshop",
     "Assemble Plasmid",
     "Generate Sequences",
 ]
-_TAB_KEYS = ["import_db", "model_repo", "worklist", "clusters", "experiments", "parts", "assemble", "generate"]
+_TAB_KEYS = ["import_db", "model_repo", "worklist", "candidates", "experiments", "parts", "assemble", "generate"]
 
 
 logger = logging.getLogger(__name__)
@@ -189,7 +189,7 @@ class StudioApp(param.Parameterized):
         self._model_repo    = ModelRepositoryPanel(self.state)
         self._assembly      = PlasmidAssemblyPanel(self.state)
         self._generate      = GenerateSequencesPanel(self.state)
-        self._cluster       = ClusterView(self.state)
+        self._candidates    = CandidateView(self.state)
         self._experiments   = ExperimentView(self.state)
 
         # ── Build persistent widgets once ─────────────────────────────────────
@@ -206,7 +206,7 @@ class StudioApp(param.Parameterized):
                 pn.panel(self._worklist.panel),
                 sizing_mode="stretch_width",
             )),
-            (_TAB_NAMES[3], pn.panel(self._cluster.panel)),
+            (_TAB_NAMES[3], pn.panel(self._candidates.panel)),
             (_TAB_NAMES[4], pn.panel(self._experiments.panel)),
             (_TAB_NAMES[5], pn.panel(self._parts.panel)),
             (_TAB_NAMES[6], pn.panel(self._assembly.panel)),

ui/components/candidate_view.py

@@ -0,0 +1,244 @@
+"""
+Candidate Analysis.
+
+Two authentic mRNA-design views over the current worklist:
+
+  A. **Comparison scorecard** — every candidate scored on the four objectives a
+     designer trades off (Expression, Stability, Immunogenicity, Manufacturability)
+     plus an overall, ranked, with a top-N shortlist.
+  B. **Sequence/structure track** — for a selected candidate, a per-position map:
+     region bands (5'UTR/Kozak/CDS/3'UTR/polyA), GC sliding window, and markers
+     for restriction sites, homopolymers, and liability motifs — i.e. *where* the
+     problems are.
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, List, Tuple
+
+import panel as pn
+import param
+import plotly.graph_objects as go
+
+from core.analysis.candidate_score import score_objectives, ObjectiveScores
+
+if TYPE_CHECKING:
+    from ui.state import AppState
+
+
+_OBJECTIVES = ["Expression", "Stability", "Immunogenicity", "Manufacturability", "Overall"]
+_REGION_COLORS = {
+    "5'UTR": "#3B82F6", "Kozak": "#D97706", "CDS": "#10B981",
+    "3'UTR": "#8B5CF6", "PolyA": "#EF4444",
+}
+
+
+def _empty(msg: str) -> pn.pane.HTML:
+    return pn.pane.HTML(f'<div style="color:#64748B;padding:30px;text-align:center;">{msg}</div>')
+
+
+def _score_color(v: float) -> Tuple[str, str]:
+    """(background, text) for a 0–100 score."""
+    if v >= 80:
+        return "#DCFCE7", "#166534"
+    if v >= 60:
+        return "#FEF9C3", "#854D0E"
+    if v >= 40:
+        return "#FFEDD5", "#9A3412"
+    return "#FEE2E2", "#991B1B"
+
+
+class CandidateView(param.Parameterized):
+    """Multi-objective candidate comparison + per-candidate track."""
+
+    def __init__(self, state: "AppState", **params: object) -> None:
+        super().__init__(**params)
+        self._state = state
+        self._shortlist = pn.widgets.IntSlider(
+            name="Shortlist top N", start=1, end=10, value=3, width=220, margin=(4, 10))
+        self._candidate = pn.widgets.Select(name="Inspect candidate", width=340, margin=(4, 10))
+
+    # ── analysis ──────────────────────────────────────────────────────────────
+    def _analyzed(self) -> List[tuple]:
+        """Return [(item, report, ObjectiveScores), …] for worklist items with content."""
+        from core.analysis.analyzer import SequenceAnalyzer
+        az = SequenceAnalyzer()
+        out = []
+        for item in self._state.worklist.items:
+            try:
+                rep = az.run_full_analysis(item.sequence)
+                out.append((item, rep, score_objectives(rep)))
+            except Exception:
+                continue
+        return out
+
+    # ── A. comparison scorecard ───────────────────────────────────────────────
+    def _comparison_table(self, analyzed: List[tuple], top_n: int) -> pn.pane.HTML:
+        if not analyzed:
+            return _empty("No analyzable sequences in the worklist.")
+        ranked = sorted(analyzed, key=lambda t: t[2].overall, reverse=True)
+
+        head = (
+            '<tr style="font-size:11px;color:#64748B;border-bottom:1px solid #E2E8F0;">'
+            '<td style="padding:5px 10px;">#</td><td style="padding:5px 10px;">Candidate</td>'
+            + "".join(f'<td style="padding:5px 10px;text-align:center;">{o}</td>' for o in _OBJECTIVES)
+            + '</tr>'
+        )
+        rows = ""
+        for i, (item, _rep, s) in enumerate(ranked, 1):
+            shortlisted = i <= top_n
+            mark = '★' if shortlisted else ''
+            name_bg = "background:#F0FDFA;" if shortlisted else ""
+            cells = ""
+            for obj in _OBJECTIVES:
+                val = s.as_row()[obj]
+                bg, fg = _score_color(val)
+                weight = "800" if obj == "Overall" else "600"
+                cells += (
+                    f'<td style="padding:4px 8px;text-align:center;">'
+                    f'<span style="display:inline-block;min-width:34px;background:{bg};color:{fg};'
+                    f'border-radius:4px;padding:2px 6px;font-weight:{weight};font-size:12px;">{val}</span></td>'
+                )
+            rows += (
+                f'<tr style="border-bottom:1px solid #F1F5F9;{name_bg}">'
+                f'<td style="padding:4px 10px;color:#94A3B8;font-size:12px;">{i}</td>'
+                f'<td style="padding:4px 10px;font-size:12px;font-weight:600;">{mark} {item.sequence.name}</td>'
+                f'{cells}</tr>'
+            )
+        legend = (
+            '<div style="font-size:11px;color:#64748B;margin-top:8px;">'
+            'Higher is better (0–100). ★ = shortlisted. '
+            'Overall = weighted blend (Expression 30% · Stability 25% · '
+            'Immunogenicity 20% · Manufacturability 25%). Heuristic scores from computed metrics.'
+            '</div>'
+        )
+        return pn.pane.HTML(
+            f'<table style="border-collapse:collapse;width:100%;">{head}{rows}</table>{legend}'
+        )
+
+    # ── B. per-candidate sequence/structure track ──────────────────────────────
+    def _track(self, analyzed: List[tuple], candidate_name: str) -> pn.viewable.Viewable:
+        match = next((t for t in analyzed if t[0].sequence.name == candidate_name), None)
+        if match is None:
+            return _empty("Select a candidate to inspect.")
+        item, report, _scores = match
+        seq = item.sequence
+
+        # region bands from component lengths (offsets line up with assembled_sequence)
+        comps = [("5'UTR", seq.five_prime_utr), ("Kozak", seq.kozak), ("CDS", seq.cds),
+                 ("3'UTR", seq.three_prime_utr), ("PolyA", seq.poly_a)]
+        bands: List[Tuple[str, int, int]] = []
+        region_off = {}
+        offset = 0
+        for nm, s in comps:
+            if s:
+                bands.append((nm, offset, offset + len(s)))
+                region_off[nm] = offset
+                offset += len(s)
+        polya_start = region_off.get("PolyA", 10 ** 12)
+
+        fig = go.Figure()
+        for nm, a, b in bands:
+            fig.add_vrect(x0=a, x1=b, fillcolor=_REGION_COLORS.get(nm, "#94A3B8"),
+                          opacity=0.12, line_width=0,
+                          annotation_text=nm, annotation_position="top left",
+                          annotation_font_size=10)
+
+        pos = report.gc_sliding_positions
+        vals = report.gc_sliding_values
+        if pos is not None and len(pos):
+            fig.add_trace(go.Scatter(x=list(pos), y=list(vals), mode="lines",
+                                     line={"color": "#0F766E", "width": 1.4}, name="GC%",
+                                     hovertemplate="pos %{x}<br>GC %{y:.0f}%<extra></extra>"))
+        fig.add_hline(y=50, line_dash="dot", line_color="#CBD5E1", opacity=0.7)
+
+        # restriction sites
+        rx, rt = [], []
+        for enz, hits in (report.restriction_hits or {}).items():
+            for h in hits:
+                rx.append(h.position); rt.append(enz)
+        if rx:
+            fig.add_trace(go.Scatter(x=rx, y=[96] * len(rx), mode="markers",
+                marker={"symbol": "triangle-down", "size": 10, "color": "#DC2626"},
+                name="Restriction site", text=rt,
+                hovertemplate="%{text}<br>pos %{x}<extra></extra>"))
+
+        # homopolymers (exclude the legitimate poly-A tail)
+        hx = [r.start for r in report.homopolymer_runs if r.start < polya_start]
+        ht = [f"{r.nucleotide}×{r.length}" for r in report.homopolymer_runs if r.start < polya_start]
+        if hx:
+            fig.add_trace(go.Scatter(x=hx, y=[89] * len(hx), mode="markers",
+                marker={"symbol": "square", "size": 9, "color": "#D97706"},
+                name="Homopolymer", text=ht,
+                hovertemplate="%{text}<br>pos %{x}<extra></extra>"))
+
+        # liability motifs
+        mx, mt = [], []
+        for h in (report.motif_hits or []):
+            mx.append(region_off.get(h.region, 0) + h.start); mt.append(h.label)
+        if mx:
+            fig.add_trace(go.Scatter(x=mx, y=[82] * len(mx), mode="markers",
+                marker={"symbol": "diamond", "size": 9, "color": "#7C3AED"},
+                name="Liability motif", text=mt,
+                hovertemplate="%{text}<br>pos %{x}<extra></extra>"))
+
+        fig.update_layout(
+            title={"text": f"{seq.name} — sequence map", "font": {"size": 13}},
+            xaxis_title="position (nt)", yaxis={"title": "GC %", "range": [0, 100]},
+            height=340, margin={"l": 55, "r": 20, "t": 40, "b": 45},
+            plot_bgcolor="#F8FAFC", paper_bgcolor="white",
+            legend={"orientation": "h", "y": -0.3, "font": {"size": 10}},
+        )
+
+        # reuse the liability scorecard for this candidate
+        from ui.components.analysis_dashboard import render_liability_panel
+        return pn.Column(
+            pn.pane.Plotly(fig, sizing_mode="stretch_width"),
+            render_liability_panel(report),
+            sizing_mode="stretch_width",
+        )
+
+    # ── panel ─────────────────────────────────────────────────────────────────
+    @param.depends("_state.worklist")
+    def panel(self) -> pn.Column:
+        wl = self._state.worklist
+        if wl is None or wl.count == 0:
+            return pn.Column(
+                pn.pane.HTML('<div style="font-size:16px;font-weight:800;padding:8px 0;">'
+                             'Candidate Analysis</div>'),
+                _empty("Worklist is empty. Import sequences to compare candidates."),
+                styles={"padding": "8px 16px"},
+            )
+
+        analyzed = self._analyzed()
+        names = [t[0].sequence.name for t in analyzed]
+        self._candidate.options = names
+        if names and (self._candidate.value not in names):
+            self._candidate.value = names[0]
+
+        self._shortlist.end = max(1, len(analyzed))
+        table = pn.bind(lambda n: self._comparison_table(analyzed, n), self._shortlist)
+        track = pn.bind(lambda nm: self._track(analyzed, nm), self._candidate)
+
+        def card(title, body, controls=None):
+            inner = [pn.pane.HTML(f'<div style="font-size:13px;font-weight:700;margin:6px 0;">{title}</div>')]
+            if controls is not None:
+                inner.append(controls)
+            inner.append(body)
+            return pn.Column(*inner, styles={"background": "white", "border": "1px solid #CBD5E1",
+                             "border-radius": "8px", "padding": "12px 14px"},
+                             margin=(0, 0, 12, 0), sizing_mode="stretch_width")
+
+        return pn.Column(
+            pn.pane.HTML(
+                '<div style="font-size:16px;font-weight:800;padding:8px 0 2px 0;">'
+                f'Candidate Analysis <span style="color:#64748B;font-size:13px;">'
+                f'({wl.count} sequences)</span></div>'
+                '<div style="font-size:12px;color:#64748B;margin-bottom:8px;">'
+                'Rank candidates across the four mRNA design objectives, then inspect where '
+                'a candidate&#39;s features and liabilities sit along the molecule.</div>'
+            ),
+            card("Comparison scorecard", pn.panel(table), self._shortlist),
+            card("Sequence / structure map", pn.panel(track), self._candidate),
+            sizing_mode="stretch_width",
+            styles={"padding": "8px 16px", "max-height": "82vh", "overflow-y": "auto"},
+        )