feat: redesign around phenotype-driven triage, not variant filtering

A table with filters made the user do the work. Rare disease triage is a different task:
which few variants could explain *this* patient's phenotype, and why. The app now answers
that, and lets a reviewer act on the answer.

Domain
- a case is a proband: a VCF plus the HPO terms observed in the patient (samples -> cases)
- HPO's gene-to-phenotype annotations are loaded as reference data (scripts/load-hpo.py)
- each candidate can be shortlisted or dismissed with a reason and a note

Ranking (app/services/triage.py, 21 tests)
- weighted sum of phenotype match, rarity, consequence severity and the model's score,
  with every component shown next to the candidate
- rarity and consequence filter; phenotype only ranks, because a real diagnosis can sit in
  a gene nobody has annotated yet and filtering on it would hide exactly that case
- ClinVar is deliberately not an input: it appears beside the result as independent
  confirmation, so nothing ranks highly merely because ClinVar already said pathogenic

UI
- the funnel is the headline: variants called -> rare -> coding candidates -> phenotype-matched
- ranked candidates with evidence chips, not a grid of everything; filters are demoted
- a variant panel showing the score breakdown, the matched HPO terms, the raw VEP record and
  links out to Ensembl/gnomAD/ClinVar, with the decision controls
- a printable case report: phenotype, funnel, shortlisted variants with reasons, provenance

API: /cases with phenotypes, /cases/{id}/candidates (funnel + ranked + weights),
/variants/{id}, /variants/{id}/decision, /cases/{id}/report, /phenotypes for the picker.
Scoring moved under the case and now answers 503 with the reason when no model registry is
reachable, instead of a 500.

Verified end to end on a simulated proband (scripts/make-demo-case.sh: real GIAB HG002
background + one real ClinVar 2-star pathogenic NF2 variant). 13 variants called -> 1 coding
candidate, and the planted variant ranks first at 0.80 on phenotype 1.00, rarity 1.00 and
consequence 1.00, with ClinVar agreeing afterwards.

Tests: api 75, ml 18, loader 16, web 27; ruff, mypy, svelte-check, terraform validate, both
kustomize overlays and the Nextflow stub run all clean.

api/app/routers/variants.py

@@ -1,60 +1,63 @@
-import uuid
-
-from fastapi import APIRouter, Query
-from sqlalchemy import Integer, case, cast, func, select
+from fastapi import APIRouter, HTTPException
+from sqlalchemy import func, select
+from sqlalchemy.dialects.postgresql import insert
 from sqlalchemy.orm import selectinload
 
 from app.db import SessionDep
-from app.models import Prediction, Variant
-from app.schemas import VariantOut, VariantPage
+from app.models import Variant, VariantDecision
+from app.schemas import CandidateOut, DecisionIn, DecisionOut, VariantDetailOut
+from app.services import candidates as case_view
+from app.services import triage
 
 router = APIRouter()
 
-# Karyotype order (1..22, X, Y, MT) instead of text order, where "10" sorts before "2".
-_chrom = func.regexp_replace(Variant.chrom, "^chr", "", "i")
-CHROM_ORDER = case(
-    (_chrom.regexp_match("^[0-9]+$"), cast(_chrom, Integer)),
-    (_chrom == "X", 23),
-    (_chrom == "Y", 24),
-    (_chrom.in_(["M", "MT"]), 25),
-    else_=26,
-)
 
-
-@router.get("", response_model=VariantPage)
-async def list_variants(
-    job_id: uuid.UUID,
-    session: SessionDep,
-    gene: str | None = None,
-    impact: str | None = Query(None, pattern="^(HIGH|MODERATE|LOW|MODIFIER)$"),
-    max_af: float | None = Query(None, ge=0, le=1),
-    min_score: float | None = Query(None, ge=0, le=1),
-    limit: int = Query(50, ge=1, le=500),
-    offset: int = Query(0, ge=0),
-) -> VariantPage:
-    stmt = select(Variant).where(Variant.job_id == job_id)
-    if gene:
-        stmt = stmt.where(Variant.gene == gene.upper())
-    if impact:
-        stmt = stmt.where(Variant.impact == impact)
-    if max_af is not None:
-        stmt = stmt.where((Variant.gnomad_af.is_(None)) | (Variant.gnomad_af <= max_af))
-    if min_score is not None:
-        stmt = stmt.join(Prediction, Prediction.variant_id == Variant.id).where(
-            Prediction.score >= min_score
+@router.get("/{variant_id}", response_model=VariantDetailOut)
+async def get_variant(variant_id: int, session: SessionDep) -> VariantDetailOut:
+    """Every piece of evidence for one variant, including the raw VEP record."""
+    variant = await session.scalar(
+        select(Variant)
+        .where(Variant.id == variant_id)
+        .options(
+            selectinload(Variant.prediction),
+            selectinload(Variant.decision),
+            selectinload(Variant.job),
         )
+    )
+    if variant is None:
+        raise HTTPException(404, "variant not found")
+    case = await case_view.get_case(session, variant.job.case_id)
+    terms = [p.hpo_id for p in case.phenotypes] if case else []
+    gene_terms = await case_view.gene_terms_for(session, {variant.gene} if variant.gene else set())
 
-    total = await session.scalar(select(func.count()).select_from(stmt.subquery()))
-    rows = await session.scalars(
-        stmt.options(selectinload(Variant.prediction))
-        # id breaks ties between split multiallelics at one position, keeping pages stable.
-        .order_by(CHROM_ORDER, Variant.chrom, Variant.pos, Variant.id)
-        .limit(limit)
-        .offset(offset)
+    # evaluate, not rank: the panel must work for a variant that did not make the candidate list.
+    scored = triage.evaluate(variant, terms, gene_terms)
+    labels = {p.hpo_id: p.label for p in case.phenotypes} if case else {}
+    base = CandidateOut.from_candidate(scored, labels).model_dump()
+    return VariantDetailOut(**base, annotations=variant.annotations or {})
+
+
+@router.post("/{variant_id}/decision", response_model=DecisionOut)
+async def decide(variant_id: int, payload: DecisionIn, session: SessionDep) -> DecisionOut:
+    if await session.get(Variant, variant_id) is None:
+        raise HTTPException(404, "variant not found")
+    stmt = insert(VariantDecision).values(
+        variant_id=variant_id, state=payload.state, reason=payload.reason, note=payload.note
     )
-    return VariantPage(
-        items=[VariantOut.model_validate(v) for v in rows],
-        total=total or 0,
-        limit=limit,
-        offset=offset,
+    # Changing your mind replaces the call rather than failing on the unique constraint.
+    await session.execute(
+        stmt.on_conflict_do_update(
+            index_elements=[VariantDecision.variant_id],
+            set_={
+                "state": stmt.excluded.state,
+                "reason": stmt.excluded.reason,
+                "note": stmt.excluded.note,
+                "decided_at": func.now(),
+            },
+        )
     )
+    await session.commit()
+    decision = await session.scalar(
+        select(VariantDecision).where(VariantDecision.variant_id == variant_id)
+    )
+    return DecisionOut.model_validate(decision)