Merge branch 'feat/risk-demographic-selector'

# Conflicts:
#	backend/app/main.py
#	frontend/src/App.tsx

Author: glebis

.gitignore

@@ -60,3 +60,7 @@ relay.db-wal
 .claude/settings.local.json
 .claude/projects/
 .claude/worktrees/
+.claude/*.lock
+
+# Local test fixtures / scratch images (not for version control)
+test-images/

backend/app/agent/tools.py

@@ -65,7 +65,7 @@ async def query_snps(args: dict[str, Any]) -> dict[str, Any]:
     annotations=ToolAnnotations(readOnlyHint=True, destructiveHint=False),
 )
 async def get_snp_detail(args: dict[str, Any]) -> dict[str, Any]:
-    snp = await _genome_db.get_snp(args["rsid"])
+    snp = await _genome_db.get_snp(args["rsid"], profile_id="default")
     if not snp:
         text = f"Variant {args['rsid']} not found in your data."
     else:

backend/app/db/genome.py

@@ -93,10 +93,13 @@ async def query_snps(
         # Need myvariant join when gene filter is used
         mv_join = "LEFT JOIN enrichments e_mv ON s.rsid = e_mv.rsid AND e_mv.source = 'myvariant'"
 
+        gw_join = "LEFT JOIN enrichments e_gw ON s.rsid = e_gw.rsid AND e_gw.source = 'gwas_catalog'"
+
         count_sql = f"""
             SELECT COUNT(DISTINCT s.rsid) FROM snps s
             LEFT JOIN enrichments e_cv ON s.rsid = e_cv.rsid AND e_cv.source = 'clinvar'
             {mv_join}
+            {gw_join}
             {where}
         """
         async with self._conn.execute(count_sql, params) as cursor:
@@ -108,10 +111,15 @@ async def query_snps(
                    s.source, s.r2_quality,
                    json_extract(e_cv.data, '$.clinical_significance') as significance,
                    json_extract(e_cv.data, '$.disease_name') as disease,
-                   json_extract(e_mv.data, '$.gene_symbol') as gene_symbol
+                   json_extract(e_mv.data, '$.gene_symbol') as gene_symbol,
+                   json_extract(e_cv.data, '$.review_status') as review_status,
+                   json_extract(e_mv.data, '$.gnomad_genome_af') as gnomad_af,
+                   json_extract(e_gw.data, '$.associations[0].beta') as effect_size,
+                   json_extract(e_gw.data, '$.associations[0].traits[0]') as effect_trait
             FROM snps s
             LEFT JOIN enrichments e_cv ON s.rsid = e_cv.rsid AND e_cv.source = 'clinvar'
             {mv_join}
+            {gw_join}
             {where}
             GROUP BY s.rsid
             ORDER BY CASE
@@ -172,8 +180,32 @@ async def list_genes(self, vault_path: str | None = None) -> list[dict]:
             key=lambda x: (-x["count"], x["gene"]),
         )
 
-    async def get_snp(self, rsid: str) -> dict | None:
-        sql = """
+    async def _snps_has_profile_column(self) -> bool:
+        """Whether the snps table carries a profile_id column.
+
+        Older single-profile databases (and some test fixtures) predate the
+        multi-profile schema; in that case we must not reference profile_id in
+        SQL or the query errors with "no such column".
+        """
+        async with self._conn.execute("PRAGMA table_info(snps)") as cursor:
+            cols = await cursor.fetchall()
+        return any(col[1] == "profile_id" for col in cols)
+
+    async def get_snp(self, rsid: str, profile_id: str = "default") -> dict | None:
+        # Scope by profile so a multi-profile DB never returns another
+        # person's genotype for the same rsID. Degrade safely on legacy
+        # single-profile schemas that lack the column.
+        #
+        # TODO(audit-17 follow-up): list_snps/query_snps/count/get_stats and
+        # other aggregates remain profile-blind and can mix profiles in a
+        # multi-profile DB. Thread profile_id through them in a follow-up.
+        if await self._snps_has_profile_column():
+            profile_filter = "AND COALESCE(s.profile_id, 'default') = ?"
+            params: list = [rsid, profile_id]
+        else:
+            profile_filter = ""
+            params = [rsid]
+        sql = f"""
             SELECT s.rsid, s.chromosome, s.position, s.genotype, s.is_rsid,
                    s.source, s.r2_quality,
                    json_extract(e_cv.data, '$.clinical_significance') as significance,
@@ -194,15 +226,15 @@ async def get_snp(self, rsid: str) -> dict | None:
             LEFT JOIN enrichments e_cv ON s.rsid = e_cv.rsid AND e_cv.source = 'clinvar'
             LEFT JOIN enrichments e_mv ON s.rsid = e_mv.rsid AND e_mv.source = 'myvariant'
             LEFT JOIN gene_snp_map gsm ON s.rsid = gsm.rsid
-            WHERE s.rsid = ?
+            WHERE s.rsid = ? {profile_filter}
         """
-        async with self._conn.execute(sql, [rsid]) as cursor:
+        async with self._conn.execute(sql, params) as cursor:
             row = await cursor.fetchone()
             return dict(row) if row else None
 
-    async def get_variant_guidance(self, rsid: str) -> dict:
+    async def get_variant_guidance(self, rsid: str, profile_id: str = "default") -> dict:
         """Generate guidance data for a variant based on its enrichments."""
-        snp = await self.get_snp(rsid)
+        snp = await self.get_snp(rsid, profile_id=profile_id)
         if not snp:
             return {}
 

backend/app/main.py

@@ -90,6 +90,7 @@ async def lifespan(app: FastAPI):
 from backend.app.routes.starter_prompts import router as starter_prompts_router
 from backend.app.routes.export import router as export_router
 from backend.app.routes.imports_route import router as imports_router
+from backend.app.routes.life_map import router as life_map_router
 
 app.include_router(snps_router)
 app.include_router(sessions_router)
@@ -103,6 +104,7 @@ async def lifespan(app: FastAPI):
 app.include_router(starter_prompts_router)
 app.include_router(export_router)
 app.include_router(imports_router)
+app.include_router(life_map_router)
 
 
 @app.get("/api/health")
@@ -111,7 +113,7 @@ async def health():
     return {"status": "ok", "variants": stats["total"]}
 
 
-ALL_VIEWS = ["snps", "mental-health", "pgx", "addiction", "risk"]
+ALL_VIEWS = ["snps", "mental-health", "pgx", "addiction", "risk", "life-map"]
 
 @app.get("/api/settings/views")
 async def get_visible_views():

backend/app/routes/gwas.py

@@ -19,10 +19,27 @@
 GWAS_CONFIG_DIR = REPO_ROOT / "config" / "gwas"
 
 
-def _count_effect_alleles(genotype: str | None, effect_allele: str | None) -> int | None:
+_COMPLEMENT = str.maketrans("ACGT", "TGCA")
+_PALINDROMIC = {frozenset(("A", "T")), frozenset(("C", "G"))}
+
+
+def _count_effect_alleles(
+    genotype: str | None,
+    effect_allele: str | None,
+    other_allele: str | None = None,
+) -> int | None:
     """Count copies of the effect allele in a diploid genotype like 'AG' or 'A/G'.
 
-    Returns None if we can't determine (missing data, indel, etc).
+    When ``other_allele`` is supplied, the genotype is validated against the
+    GWAS {effect, other} allele pair so we can orient it to the reference strand:
+
+    * If the genotype alleles already fall within {effect, other}, count directly.
+    * Otherwise try the complement strand; count only if it then matches.
+    * Palindromic SNPs (A/T, C/G) are their own complement and therefore
+      un-orientable from genotype alone — return None.
+    * Genotypes matching neither orientation are unresolvable — return None.
+
+    Returns None if we can't determine (missing data, indel, strand-ambiguous, etc).
     """
     if not genotype or not effect_allele:
         return None
@@ -34,9 +51,52 @@ def _count_effect_alleles(genotype: str | None, effect_allele: str | None) -> in
         return None
     if len(ea) != 1:
         return None
+
+    oa = other_allele.upper() if other_allele else None
+    if oa and len(oa) != 1:
+        return None
+
+    if oa:
+        expected = {ea, oa}
+        # Palindromic SNPs are un-orientable from genotype alone.
+        if frozenset(expected) in _PALINDROMIC:
+            return None
+
+        if set(g) <= expected:
+            return sum(1 for base in g if base == ea)
+
+        comp = g.translate(_COMPLEMENT)
+        if set(comp) <= expected:
+            return sum(1 for base in comp if base == ea)
+
+        # Matches neither orientation — unresolvable.
+        return None
+
     return sum(1 for base in g if base == ea)
 
 
+def _count_traits_per_entry(
+    user_genotype: str | None, traits_list: list[dict]
+) -> list[dict]:
+    """Attach a per-trait ``effect_allele_count`` to each pleiotropic trait entry.
+
+    Each trait may carry a different effect/other allele for the same SNP, so the
+    dosage is computed independently per entry rather than reusing one trait's
+    effect allele for all (audit finding #12).
+    """
+    return [
+        {
+            **t,
+            "effect_allele_count": _count_effect_alleles(
+                user_genotype,
+                t.get("effect_allele"),
+                t.get("other_allele"),
+            ),
+        }
+        for t in traits_list
+    ]
+
+
 @router.get("/traits")
 async def list_traits():
     """List traits that have pre-computed GWAS hits available."""
@@ -108,12 +168,11 @@ async def get_gwas_overlap():
 
     results: list[dict] = []
     for rsid, traits_list in pleiotropic.items():
-        snp = await genome_db.get_snp(rsid)
-        # Use the first trait's effect allele for counting (they may differ across studies)
-        ea = traits_list[0].get("effect_allele")
-        ea_count = _count_effect_alleles(
-            snp.get("genotype") if snp else None, ea
-        )
+        snp = await genome_db.get_snp(rsid, profile_id="default")
+        user_genotype = snp.get("genotype") if snp else None
+        # Count the effect-allele dosage PER trait — a pleiotropic SNP can carry
+        # different effect/other alleles across studies (audit finding #12).
+        traits_with_counts = _count_traits_per_entry(user_genotype, traits_list)
 
         avg_p = sum(t["p_value"] for t in traits_list if t["p_value"]) / max(
             sum(1 for t in traits_list if t["p_value"]), 1
@@ -125,9 +184,8 @@ async def get_gwas_overlap():
             "pos": rsid_info[rsid]["pos"],
             "n_traits": len(traits_list),
             "avg_p_value": avg_p,
-            "user_genotype": snp.get("genotype") if snp else None,
-            "effect_allele_count": ea_count,
-            "traits": traits_list,
+            "user_genotype": user_genotype,
+            "traits": traits_with_counts,
         })
 
     # Sort: most traits first, then lowest average p-value
@@ -175,10 +233,10 @@ async def get_gwas_summary():
             rsid = hit.get("rsid")
             if not rsid:
                 continue
-            snp = await genome_db.get_snp(rsid)
+            snp = await genome_db.get_snp(rsid, profile_id="default")
             if not snp:
                 continue
-            ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"))
+            ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"), hit.get("other_allele"))
             if ea_count is None:
                 continue
 
@@ -250,10 +308,10 @@ async def _compute_trait_summary(trait: str) -> dict | None:
         rsid = hit.get("rsid")
         if not rsid:
             continue
-        snp = await genome_db.get_snp(rsid)
+        snp = await genome_db.get_snp(rsid, profile_id="default")
         if not snp:
             continue
-        ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"))
+        ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"), hit.get("other_allele"))
         if ea_count is None:
             continue
 
@@ -358,11 +416,11 @@ async def get_addiction_gwas_summary():
         if not rsid:
             continue
 
-        snp = await genome_db.get_snp(rsid)
+        snp = await genome_db.get_snp(rsid, profile_id="default")
         if not snp:
             continue
 
-        ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"))
+        ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"), hit.get("other_allele"))
         if ea_count is None:
             continue
 
@@ -456,11 +514,11 @@ async def get_gwas_matches(trait: str, clumped: bool = Query(False)):
         if not rsid:
             continue
 
-        snp = await genome_db.get_snp(rsid)
+        snp = await genome_db.get_snp(rsid, profile_id="default")
         if not snp:
             continue
 
-        ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"))
+        ea_count = _count_effect_alleles(snp.get("genotype"), hit.get("effect_allele"), hit.get("other_allele"))
         if ea_count is None:
             continue
 

backend/app/routes/gwas_analytics.py

@@ -78,7 +78,7 @@ async def get_gene_map():
         if not rsid:
             continue
 
-        snp = await genome_db.get_snp(rsid)
+        snp = await genome_db.get_snp(rsid, profile_id="default")
         if not snp:
             continue
 
@@ -190,7 +190,7 @@ async def get_trait_prs(trait: str):
         if not rsid:
             continue
 
-        snp = await genome_db.get_snp(rsid)
+        snp = await genome_db.get_snp(rsid, profile_id="default")
         if not snp:
             continue
 

backend/app/routes/life_map.py

@@ -0,0 +1,28 @@
+"""Migrant Life-Map routes (#27).
+
+Serves the committed, version-stamped life-table data produced by
+``scripts/fetch_life_expectancy.py``. Dumb data server — all blend logic lives in
+the frontend (``lib/lifeBlend.ts``). The modifier catalogue is served via the
+existing generic ``/api/config/{name}`` endpoint (``config/life-modifiers.yaml``).
+"""
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+
+router = APIRouter(prefix="/api/life-map", tags=["life-map"])
+
+_DATA_FILE = Path(__file__).resolve().parents[3] / "config" / "life_tables.json"
+
+
+@router.get("/life-tables")
+async def get_life_tables() -> dict:
+    """Return the committed life-table dataset (countries x sex x age -> ex)."""
+    if not _DATA_FILE.exists():
+        raise HTTPException(status_code=404, detail="Life tables not generated")
+    try:
+        return json.loads(_DATA_FILE.read_text())
+    except Exception as exc:  # noqa: BLE001
+        raise HTTPException(status_code=500, detail=f"Failed to read life tables: {exc}")

backend/app/routes/snps.py

@@ -37,15 +37,15 @@ async def list_genes():
 
 @router.get("/snps/{rsid}")
 async def get_snp(rsid: str):
-    snp = await genome_db.get_snp(rsid)
+    snp = await genome_db.get_snp(rsid, profile_id="default")
     if not snp:
         raise HTTPException(status_code=404, detail="Variant not found")
     return snp
 
 
 @router.get("/snps/{rsid}/guidance")
 async def get_variant_guidance(rsid: str):
-    guidance = await genome_db.get_variant_guidance(rsid)
+    guidance = await genome_db.get_variant_guidance(rsid, profile_id="default")
     if not guidance:
         raise HTTPException(status_code=404, detail="Variant not found")
     return guidance