feat(landscape): merge trials-by-phase wheel into Therapy Landscape tab (#21)

Fold the experimental "Trials by Phase" tab and the sunburst-based Therapy
Landscape into a single "Therapy Landscape" tab whose hero is the pipeline
wheel (mechanism sectors × phase rings):

- Filters on one row (Recruitment status, Trial phase, Mechanism); every
control redraws the wheel. Mechanism narrows it to a single sector.
- Trial phase is a multi-select checkbox that drives the geometry: one ring
per checked phase (inner -> outer). Phase 3 and Expanded Access (EAP) share
the outer "Phase 3 / EAP" ring.
- Grey dots mark compounds with no recruiting/active trial; "Others / Multiple"
recolored yellow so grey stays reserved for inactive.
- Mechanism -> Compound drill-down shows pipeline stage, evidence confidence,
and a trials table (status badges + NCT links).
- Remove the dead sunburst path.

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

app.py

@@ -101,7 +101,7 @@ _kg_nodes = _graph.number_of_nodes() if _graph else 0
 import landscape as landscape_mod
 
 _landscape = landscape_mod.load_landscape()
-_landscape_classes = landscape_mod.class_names(_landscape)
+_mech_options = landscape_mod.mechanism_filter_options(_landscape)
 
 # ── Example questions ─────────────────────────────────────────────────────────
 
@@ -173,27 +173,22 @@ Always verify claims with primary sources before applying to patient care.
 </div>"""
 
 
-def _landscape_select(class_name: str, phases):
-    """When the class (or phase filter) changes: repopulate therapies and show the first one's detail."""
-    labels = landscape_mod.therapy_labels(_landscape, class_name, phases)
+def _refresh(status: str, phases: list, mech: str):
+    """Any filter changed: redraw the wheel (rings = selected phases, narrowed by mechanism)."""
+    labels = landscape_mod.compound_labels(_landscape, mech, status, phases)
     first = labels[0] if labels else None
     return (
+        landscape_mod.build_pipeline_svg(_landscape, status, phases, mech),
         gr.update(choices=labels, value=first),
-        landscape_mod.therapy_detail_md(_landscape, class_name, first or ""),
-        landscape_mod.trials_table_html(_landscape, class_name, first or ""),
+        landscape_mod.compound_detail_md(_landscape, first or ""),
+        landscape_mod.compound_trials_html(_landscape, first or ""),
     )
 
 
-def _phase_change(phases, class_name: str):
-    """Phase filter: rebuild the sunburst and repopulate the current class's therapies."""
-    therapy_update, detail, trials = _landscape_select(class_name, phases)
-    return (landscape_mod.build_sunburst(_landscape, phases), therapy_update, detail, trials)
-
-
-def _therapy_select(class_name: str, therapy_label: str):
+def _compound_change(label: str):
     return (
-        landscape_mod.therapy_detail_md(_landscape, class_name, therapy_label),
-        landscape_mod.trials_table_html(_landscape, class_name, therapy_label),
+        landscape_mod.compound_detail_md(_landscape, label),
+        landscape_mod.compound_trials_html(_landscape, label),
     )
 
 
@@ -250,56 +245,65 @@ with gr.Blocks(title="Candle-Fire — ALS Research Intelligence") as demo:
         with gr.Tab("🧭 Therapy Landscape"):
             with gr.Column(elem_classes="container"):
                 gr.Markdown(
-                    "### 🧭 Experimental ALS Therapy Landscape\n"
-                    "Explore experimental therapies by **mechanism class → therapy → clinical trials** "
-                    "(recruiting & closed). Click a wedge to zoom; use the selectors for trial details."
+                    "### 🧭 ALS Therapeutic Pipeline by Clinical Trial Phase\n"
+                    "Mechanism groups are **sectors**; the three trial phases are **concentric "
+                    "rings** (inner = Phase 1, outer = Phase 3). Each **dot is a compound** — "
+                    "hover to see its name; **grey dots** have no recruiting/active trial. Use the "
+                    "filters to narrow the wheel, and pick a **mechanism** to see its compounds' "
+                    "pipeline stage, evidence confidence, and trials."
                 )
                 if _landscape is None:
                     gr.Markdown(
                         "*Landscape not built yet — run `uv run python scripts/build_landscape.py`.*"
                     )
                 else:
-                    _init_class = _landscape_classes[0]
-                    _init_labels = landscape_mod.therapy_labels(_landscape, _init_class)
+                    _init_mech = landscape_mod.ALL_MECHANISMS
+                    _init_labels = landscape_mod.compound_labels(_landscape, _init_mech)
                     _init_label = _init_labels[0] if _init_labels else None
 
-                    sunburst = gr.Plot(landscape_mod.build_sunburst(_landscape), show_label=False)
-
-                    phase_cb = gr.CheckboxGroup(
-                        choices=landscape_mod.PHASE_OPTIONS, value=landscape_mod.PHASE_OPTIONS,
-                        label="Filter by trial phase",
-                        info="Show therapies with a trial in the selected phase(s). All selected = the whole picture.",
-                    )
-
                     with gr.Row():
-                        class_dd = gr.Dropdown(
-                            choices=_landscape_classes, value=_init_class,
-                            label="Mechanism class", scale=1,
+                        status_dd = gr.Dropdown(
+                            choices=landscape_mod.STATUS_FILTER_OPTIONS, value="All trials",
+                            label="Recruitment status", scale=1,
+                            info="Filter the wheel to compounds with a recruiting trial (or without one).",
+                        )
+                        phase_cb = gr.CheckboxGroup(
+                            choices=landscape_mod.PHASE_RINGS, value=landscape_mod.PHASE_RINGS,
+                            label="Trial phase", scale=1,
+                            info="Each checked phase is drawn as a ring (inner → outer).",
                         )
-                        therapy_dd = gr.Dropdown(
-                            choices=_init_labels, value=_init_label,
-                            label="Therapy", scale=1,
+                        mech_dd = gr.Dropdown(
+                            choices=_mech_options, value=_init_mech,
+                            label="Mechanism", scale=1,
+                            info="Narrow the wheel to a single mechanism.",
                         )
 
+                    wheel_html = gr.HTML(
+                        landscape_mod.build_pipeline_svg(
+                            _landscape, "All trials", landscape_mod.PHASE_RINGS, _init_mech)
+                    )
+
+                    compound_dd = gr.Dropdown(
+                        choices=_init_labels, value=_init_label,
+                        label="Compound — pipeline stage, evidence confidence & trials below",
+                    )
+
                     detail_md = gr.Markdown(
-                        landscape_mod.therapy_detail_md(_landscape, _init_class, _init_label or "")
+                        landscape_mod.compound_detail_md(_landscape, _init_label or "")
                     )
                     trials_html = gr.HTML(
-                        landscape_mod.trials_table_html(_landscape, _init_class, _init_label or "")
+                        landscape_mod.compound_trials_html(_landscape, _init_label or "")
                     )
 
-                    class_dd.change(
-                        _landscape_select, inputs=[class_dd, phase_cb],
-                        outputs=[therapy_dd, detail_md, trials_html],
-                    )
-                    therapy_dd.change(
-                        _therapy_select, inputs=[class_dd, therapy_dd],
+                    for _f in (status_dd, phase_cb, mech_dd):
+                        _f.change(
+                            _refresh, inputs=[status_dd, phase_cb, mech_dd],
+                            outputs=[wheel_html, compound_dd, detail_md, trials_html],
+                        )
+                    compound_dd.change(
+                        _compound_change, inputs=[compound_dd],
                         outputs=[detail_md, trials_html],
                     )
-                    phase_cb.change(
-                        _phase_change, inputs=[phase_cb, class_dd],
-                        outputs=[sunburst, therapy_dd, detail_md, trials_html],
-                    )
 
                 gr.HTML(_DISCLAIMER_MD)
 

landscape.py

@@ -1,9 +1,12 @@
-"""Rendering helpers for the Experimental ALS Therapy Landscape tab (v2: multi-label).
-
-Loads data/landscape/landscape.json and turns it into a Plotly sunburst (mechanism class →
-primary therapy) plus a detail panel that lists every mechanism a therapy acts through (with role,
-confidence, and justification) and a trials table with status badges + NCT links. Therapies whose
-mechanism could not be established are shown honestly under "Insufficient evidence".
+"""Rendering helpers for the Experimental ALS Therapy Landscape tab.
+
+Loads data/landscape/landscape.json and renders a single "ALS Therapeutic Pipeline by
+Clinical Trial Phase" wheel: mechanism groups are angular SECTORS, the three trial phases
+are concentric RINGS (inner = Phase 1, outer = Phase 3), and each compound is a dot inside
+its sector×ring cell (hover shows its name). Dots go grey when the compound has no
+recruiting/active trial in the current view. Two dropdowns filter the wheel (recruitment
+status + trial phase); a Mechanism dropdown surfaces a group's compounds, each with its
+pipeline stage, mechanism confidence, and a trials table.
 """
 from __future__ import annotations
 
@@ -14,44 +17,47 @@ from config import LANDSCAPE_PATH
 
 _INSUFFICIENT = "Insufficient evidence"
 
-_CLASS_COLORS = {
-    "TDP-43 proteinopathy": "#6C5CE7", "SOD1": "#0984E3", "C9orf72": "#00B894", "FUS": "#00CEC9",
-    "Neuroinflammation": "#E17055", "Oxidative stress": "#D63031", "Mitochondrial dysfunction": "#E84393",
-    "Glutamate excitotoxicity": "#FDCB6E", "Proteostasis / autophagy": "#A29BFE",
-    "RNA metabolism": "#74B9FF", "Neurotrophic / regenerative": "#55EFC4",
-    "Symptomatic / Other": "#B2BEC3", _INSUFFICIENT: "#DFE6E9",
-}
-_DEFAULT_COLOR = "#B2BEC3"
 _STATUS_BADGE = {
     "recruiting": ("#00B894", "Recruiting"), "active": ("#0984E3", "Active"),
     "completed": ("#636E72", "Completed"), "terminated": ("#D63031", "Terminated"),
     "other": ("#B2BEC3", "Unknown"),
 }
 
+# Recruitment-status filter for the pipeline wheel.
+STATUS_FILTER_OPTIONS = ["All trials", "Recruiting", "Not recruiting"]
+# Sentinel for the mechanism filter meaning "don't narrow the wheel to one group".
+ALL_MECHANISMS = "All mechanisms"
+
+# Pipeline-wheel rings, inner → outer. Phase 3 and Expanded Access (EAP) share the outer
+# ring. These double as the "Trial phase" checkbox options. (Phase 4 / NA are never placed.)
+PHASE_RINGS = ["Phase 1", "Phase 2", "Phase 3 / EAP"]
 
-PHASE_OPTIONS = ["Phase 1", "Phase 2", "Phase 3", "Phase 4", "Not applicable"]
+# Grey used for compounds with no recruiting/active trial in the current view.
+_INACTIVE_COLOR = "#B8BFC7"
 
 
 def _phase_buckets(phase: str) -> set:
-    """Map a ClinicalTrials.gov phase string (incl. combos like 'PHASE1, PHASE2') to UI buckets."""
+    """Map a ClinicalTrials.gov phase string to wheel rings (Phase 3 + Expanded Access merge)."""
     p = (phase or "").upper()
     b = set()
     if "PHASE1" in p:  # also catches EARLY_PHASE1
         b.add("Phase 1")
     if "PHASE2" in p:
         b.add("Phase 2")
-    if "PHASE3" in p:
-        b.add("Phase 3")
-    if "PHASE4" in p:
-        b.add("Phase 4")
-    return b or {"Not applicable"}  # NA / Expanded Access / blank
-
-
-def _therapy_matches_phases(t: dict, selected: set | None) -> bool:
-    """A therapy is shown if any of its trials falls in a selected phase. None/all = whole picture."""
-    if not selected or len(selected) >= len(PHASE_OPTIONS):
-        return True
-    return any(_phase_buckets(tr.get("phase", "")) & selected for tr in t["trials"])
+    if "PHASE3" in p or "EXPANDED" in p or "ACCESS" in p:
+        b.add("Phase 3 / EAP")
+    return b or {"Not applicable"}  # PHASE4 / NA / blank are not placed on the wheel
+
+
+def _top_ring(trials: list[dict]) -> str | None:
+    """Most advanced wheel ring (PHASE_RINGS order) present across a compound's trials."""
+    present: set = set()
+    for tr in trials:
+        present |= _phase_buckets(tr.get("phase", ""))
+    for ring in reversed(PHASE_RINGS):
+        if ring in present:
+            return ring
+    return None
 
 
 def load_landscape() -> dict | None:
@@ -63,99 +69,380 @@ def load_landscape() -> dict | None:
         return None
 
 
-def class_names(landscape: dict | None) -> list[str]:
+# ── "ALS Therapeutic Pipeline by Clinical Trial Phase" wheel (inline SVG) ──────
+# Magazine-style wheel: mechanism groups are equal angular SECTORS, the three
+# trial phases are concentric RINGS (inner=Phase 1, outer=Phase 3), and each
+# compound is a dot inside its sector×ring cell (hover shows its name). Driven by
+# real landscape data; the app's 12 mechanism classes are mapped to 8 display groups.
+
+def _all_compounds(landscape: dict) -> list[dict]:
+    """Distinct compounds (therapies) across all classes + unclassified, deduped by name.
+
+    A therapy is multi-label (appears under each class it acts through), but every copy
+    carries the same `mechanisms` and `trials`, so keeping the first is sufficient.
+    """
+    seen: dict[str, dict] = {}
+    for c in landscape.get("classifications", []):
+        for t in c.get("therapies", []):
+            seen.setdefault(t["name"], t)
+    for t in landscape.get("unclassified", []):
+        seen.setdefault(t["name"], t)
+    return list(seen.values())
+
+
+def _primary_class(therapy: dict) -> str:
+    """The compound's dominant mechanism class (primary role, else highest confidence)."""
+    mechs = therapy.get("mechanisms") or []
+    if not mechs:
+        return _INSUFFICIENT
+    pool = [m for m in mechs if m.get("role") == "primary"] or mechs
+    best = max(pool, key=lambda m: m.get("confidence", 0) or 0)
+    return best.get("class", _INSUFFICIENT)
+
+
+def _filter_trials(trials: list[dict], status_filter: str, phases: list | None = None) -> list[dict]:
+    """Filter a compound's trials by recruitment status and the selected wheel rings.
+
+    `phases` is a list of PHASE_RINGS labels (None = all rings). Trials that map only to a
+    non-ring bucket (Phase 4 / NA) are always dropped — the wheel is Phase 1–3/EAP only.
+    """
+    out = trials
+    if status_filter == "Recruiting":
+        out = [tr for tr in out if tr.get("status_group") == "recruiting"]
+    elif status_filter == "Not recruiting":
+        out = [tr for tr in out if tr.get("status_group") != "recruiting"]
+    selected = set(phases) if phases else set(PHASE_RINGS)
+    out = [tr for tr in out if _phase_buckets(tr.get("phase", "")) & selected]
+    return list(out)
+
+
+def _compound_active(trials: list[dict]) -> bool:
+    """True if any trial is recruiting or active-not-recruiting (drives dot coloring)."""
+    return any(tr.get("status_group") in ("recruiting", "active") for tr in trials)
+
+
+# Eight display groups (clockwise from top) and their colors, matching the
+# reference infographic. The app's finer 12-class taxonomy maps down to these.
+GROUP_ORDER = [
+    "Neuroinflammation / Immunity",
+    "RNA / Gene Targeting",
+    "Neuroprotection / Cell Survival",
+    "Protein Homeostasis / TDP-43 Pathology",
+    "Metabolic / Mitochondrial Function",
+    "Neuromuscular Function",
+    "Stem Cell / Regenerative",
+    "Others / Multiple",
+]
+GROUP_COLORS = {
+    "Neuroinflammation / Immunity": "#4C6FB1",
+    "RNA / Gene Targeting": "#E4586E",
+    "Neuroprotection / Cell Survival": "#26B6A6",
+    "Protein Homeostasis / TDP-43 Pathology": "#EFAA3A",
+    "Metabolic / Mitochondrial Function": "#9B7EC8",
+    "Neuromuscular Function": "#EE7B4E",
+    "Stem Cell / Regenerative": "#5BB56A",
+    "Others / Multiple": "#F4CE14",  # yellow (grey is reserved for inactive compounds)
+}
+_CLASS_TO_GROUP = {
+    "TDP-43 proteinopathy": "Protein Homeostasis / TDP-43 Pathology",
+    "Proteostasis / autophagy": "Protein Homeostasis / TDP-43 Pathology",
+    "SOD1": "RNA / Gene Targeting",
+    "C9orf72": "RNA / Gene Targeting",
+    "FUS": "RNA / Gene Targeting",
+    "RNA metabolism": "RNA / Gene Targeting",
+    "Neuroinflammation": "Neuroinflammation / Immunity",
+    "Oxidative stress": "Neuroprotection / Cell Survival",
+    "Glutamate excitotoxicity": "Neuroprotection / Cell Survival",
+    "Mitochondrial dysfunction": "Metabolic / Mitochondrial Function",
+    "Neurotrophic / regenerative": "Stem Cell / Regenerative",
+    "Symptomatic / Other": "Others / Multiple",
+    _INSUFFICIENT: "Others / Multiple",
+}
+
+_DOT_CAP = 12  # max dots drawn per sector×ring cell (real counts live in hover/summary)
+
+
+def _group_of(therapy: dict) -> str:
+    return _CLASS_TO_GROUP.get(_primary_class(therapy), "Others / Multiple")
+
+
+def _pipeline_grid(landscape: dict | None, status_filter: str, phases: list,
+                   mech_filter: str = ALL_MECHANISMS) -> dict:
+    """{group: {ring: [(compound name, is_active)]}} over the filtered, ring-placed compounds.
+
+    `phases` is the list of selected PHASE_RINGS; `mech_filter` other than ALL_MECHANISMS
+    narrows the wheel to a single mechanism group. Each compound lands in the most advanced
+    selected ring it has a trial in.
+    """
+    grid = {g: {r: [] for r in PHASE_RINGS} for g in GROUP_ORDER}
+    if landscape:
+        for t in _all_compounds(landscape):
+            group = _group_of(t)
+            if mech_filter != ALL_MECHANISMS and group != mech_filter:
+                continue
+            trials = _filter_trials(t.get("trials", []), status_filter, phases)
+            if not trials:
+                continue
+            ring = _top_ring(trials)
+            if not ring:
+                continue
+            grid[group][ring].append((t["name"], _compound_active(trials)))
+    return grid
+
+
+def _polar_xy(cx: float, cy: float, r: float, ang_deg: float) -> tuple:
+    """Angle 0 = top (12 o'clock), increasing clockwise, in screen coords."""
+    import math
+    t = math.radians(ang_deg - 90.0)
+    return cx + r * math.cos(t), cy + r * math.sin(t)
+
+
+def _annular_sector_path(cx, cy, r_in, r_out, a0, a1) -> str:
+    large = 1 if (a1 - a0) % 360 > 180 else 0
+    x0o, y0o = _polar_xy(cx, cy, r_out, a0)
+    x1o, y1o = _polar_xy(cx, cy, r_out, a1)
+    x1i, y1i = _polar_xy(cx, cy, r_in, a1)
+    x0i, y0i = _polar_xy(cx, cy, r_in, a0)
+    return (f"M {x0o:.1f} {y0o:.1f} A {r_out:.1f} {r_out:.1f} 0 {large} 1 {x1o:.1f} {y1o:.1f} "
+            f"L {x1i:.1f} {y1i:.1f} A {r_in:.1f} {r_in:.1f} 0 {large} 0 {x0i:.1f} {y0i:.1f} Z")
+
+
+def _cell_dots(cx, cy, r_in, r_out, a0, a1, cells, col) -> str:
+    """Lay up to _DOT_CAP compound dots on a jittered grid inside one annular cell.
+
+    `cells` is a list of (name, is_active); active dots take the group `col`, inactive grey.
+    """
+    import math
+    n = min(len(cells), _DOT_CAP)
+    if n == 0:
+        return ""
+    cols = 4 if n > 6 else max(1, min(n, 3))
+    rows = max(1, math.ceil(n / cols))
+    rr0, rr1 = r_in + 13, r_out - 13
+    aa0, aa1 = a0 + 3.0, a1 - 3.0
+    out = []
+    for k, (name, active) in enumerate(cells[:n]):
+        row, col_i = divmod(k, cols)
+        in_row = min(cols, n - row * cols)
+        fr = (row + 0.5) / rows
+        fa = (col_i + 0.5) / in_row
+        jr = ((k * 37) % 7 - 3) * 1.1
+        ja = ((k * 53) % 5 - 2) * 0.6
+        r = rr0 + fr * (rr1 - rr0) + jr
+        a = aa0 + fa * (aa1 - aa0) + ja
+        x, y = _polar_xy(cx, cy, r, a)
+        fill = col if active else _INACTIVE_COLOR
+        out.append(f'<circle cx="{x:.1f}" cy="{y:.1f}" r="5" fill="{fill}" '
+                   f'stroke="#fff" stroke-width="1.3"><title>{html.escape(name)}</title></circle>')
+    return "".join(out)
+
+
+def build_pipeline_svg(landscape: dict | None, status_filter: str = "All trials",
+                       phases: list | None = None,
+                       mech_filter: str = ALL_MECHANISMS) -> str:
+    """Inline-SVG 'ALS Therapeutic Pipeline by Phase' infographic (see section header).
+
+    `phases` (list of PHASE_RINGS labels; None = all) drives BOTH the filter and the geometry:
+    one concentric ring is drawn per selected phase, inner → outer in PHASE_RINGS order.
+    """
+    rings = [r for r in PHASE_RINGS if r in set(phases)] if phases else list(PHASE_RINGS)
+    grid = _pipeline_grid(landscape, status_filter, rings, mech_filter)
+    groups = [g for g in GROUP_ORDER if any(grid[g][r] for r in rings)]
+    ph_tot = {r: sum(len(grid[g][r]) for g in groups) for r in rings}
+    total = sum(ph_tot.values())
+
+    if not groups or total == 0 or not rings:
+        sel = ", ".join(rings) if rings else "no phases"
+        return ('<div style="padding:40px;text-align:center;color:#888;font-size:15px;">'
+                f'No trials match “{html.escape(status_filter)} · {html.escape(sel)} · '
+                f'{html.escape(mech_filter)}”.</div>')
+
+    W = 720
+    cx = cy = W / 2
+    r_hub = 78
+    r_out = 338
+    nr = len(rings)
+    t = (r_out - r_hub) / nr  # ring thickness recomputed for the number of selected phases
+    n = len(groups)
+    seg = 360.0 / n
+    gap_a = 1.4
+
+    mx, my_t, my_b = 116, 46, 70  # margins so perimeter labels aren't clipped
+    svg = [f'<svg viewBox="{-mx} {-my_t} {W + 2 * mx} {W + my_t + my_b}" width="100%" '
+           f'style="max-width:840px;height:auto;" '
+           'font-family="-apple-system,Segoe UI,Roboto,sans-serif">']
+
+    labels = []  # perimeter category + exemplar labels, drawn after wedges
+    for gi, g in enumerate(groups):
+        col = GROUP_COLORS[g]
+        center = gi * seg  # group 0 centered at top
+        a0, a1 = center - seg / 2 + gap_a, center + seg / 2 - gap_a
+        for i, ring in enumerate(rings):
+            ri = r_hub + i * t + 2.5
+            ro = r_hub + (i + 1) * t - 2.5
+            cells = sorted(grid[g][ring], key=lambda c: c[0])
+            cnt = len(cells)
+            path = _annular_sector_path(cx, cy, ri, ro, a0, a1)
+            fillop = 0.13 + 0.05 * i
+            svg.append(f'<path d="{path}" fill="{col}" fill-opacity="{fillop:.2f}" '
+                       f'stroke="#fff" stroke-width="2"><title>{html.escape(g)} — {html.escape(ring)}: '
+                       f'{cnt} compound{"s" if cnt != 1 else ""}</title></path>')
+            svg.append(_cell_dots(cx, cy, ri, ro, a0, a1, cells, col))
+
+        # perimeter label: category name (wrapped at " / ") + count + top exemplar
+        exemplar = next((sorted(grid[g][r], key=lambda c: c[0])[0][0]
+                         for r in reversed(rings) if grid[g][r]), "")
+        lx, ly = _polar_xy(cx, cy, r_out + 22, center)
+        if 15 < center < 165:
+            anchor, x = "start", lx + 4
+        elif 195 < center < 345:
+            anchor, x = "end", lx - 4
+        else:
+            anchor, x = "middle", lx
+        gcnt = sum(len(grid[g][r]) for r in rings)
+        parts = [html.escape(s) for s in g.split(" / ")]
+        cnt_tspan = f'<tspan font-weight="400" fill="#98a0aa"> ({gcnt})</tspan>'
+        common = f'x="{x:.1f}" text-anchor="{anchor}" font-size="12.5" font-weight="700" fill="{col}"'
+        if len(parts) >= 2:
+            lab = (f'<text {common} y="{ly:.1f}">{parts[0]} /</text>'
+                   f'<text {common} y="{ly + 14:.1f}">{" / ".join(parts[1:])}{cnt_tspan}</text>')
+            yy = ly + 29
+        else:
+            lab = f'<text {common} y="{ly:.1f}">{parts[0]}{cnt_tspan}</text>'
+            yy = ly + 15
+        if exemplar:
+            lab += (f'<text x="{x:.1f}" y="{yy:.1f}" text-anchor="{anchor}" '
+                    f'font-size="10.5" fill="#8a929c">e.g. {html.escape(exemplar[:20])}</text>')
+        labels.append(lab)
+
+    svg.extend(labels)
+
+    # center hub
+    svg.append(f'<circle cx="{cx}" cy="{cy}" r="{r_hub - 6}" fill="#fff" stroke="#dde5ef" stroke-width="2"/>')
+    svg.append(f'<text x="{cx}" y="{cy - 4}" text-anchor="middle" font-size="27" font-weight="800" '
+               f'fill="#2b3a4a" letter-spacing="1">ALS</text>')
+    svg.append(f'<text x="{cx}" y="{cy + 15}" text-anchor="middle" font-size="10.5" '
+               f'fill="#6b7683">Therapeutic Pipeline</text>')
+    svg.append(f'<text x="{cx}" y="{cy + 34}" text-anchor="middle" font-size="15">🧬</text>')
+
+    # ring labels, stacked at top with a white halo for legibility
+    for i, ring in enumerate(rings):
+        rmid = r_hub + (i + 0.5) * t
+        _, y = _polar_xy(cx, cy, rmid, 0)
+        svg.append(f'<text x="{cx}" y="{y - 3:.1f}" text-anchor="middle" font-size="13.5" '
+                   f'font-weight="800" fill="#3a4a5a" stroke="#fff" stroke-width="3.2" '
+                   f'paint-order="stroke" style="paint-order:stroke">{html.escape(ring)}</text>')
+        svg.append(f'<text x="{cx}" y="{y + 12:.1f}" text-anchor="middle" font-size="11.5" '
+                   f'font-weight="700" fill="#5a6675" stroke="#fff" stroke-width="3" '
+                   f'paint-order="stroke" style="paint-order:stroke">({ph_tot[ring]})</text>')
+    svg.append("</svg>")
+
+    # ── side panels (legend + summary) ──
+    legend_rows = "".join(
+        f'<div style="display:flex;align-items:center;gap:8px;margin:5px 0;font-size:12px;color:#3a4453;">'
+        f'<span style="width:11px;height:11px;border-radius:50%;background:{GROUP_COLORS[g]};'
+        f'flex:0 0 auto;"></span><span>{html.escape(g)}</span>'
+        f'<span style="margin-left:auto;color:#98a0aa;">{sum(len(grid[g][r]) for r in rings)}</span></div>'
+        for g in groups)
+    legend_rows += (
+        '<div style="display:flex;align-items:center;gap:8px;margin:5px 0;font-size:12px;color:#3a4453;'
+        'border-top:1px solid #eef2f6;padding-top:6px;">'
+        f'<span style="width:11px;height:11px;border-radius:50%;background:{_INACTIVE_COLOR};'
+        'flex:0 0 auto;"></span><span>Inactive — no recruiting/active trial</span></div>')
+    legend = (
+        '<div style="border:1px solid #e6ebf1;border-radius:12px;padding:12px 14px;background:#fff;">'
+        '<div style="font-weight:700;color:#2b3a4a;font-size:13px;margin-bottom:6px;">Mechanism of Action</div>'
+        f'{legend_rows}</div>')
+
+    def _row(lbl, val, sub, strong=False):
+        w = "800" if strong else "600"
+        return (f'<div style="display:flex;justify-content:space-between;align-items:baseline;'
+                f'padding:7px 0;border-top:1px solid #eef2f6;">'
+                f'<span style="color:#3a4453;font-weight:{w};font-size:13px;">{lbl}</span>'
+                f'<span style="text-align:right;"><b style="font-size:15px;color:#2b3a4a;">{val}</b>'
+                f'<span style="display:block;font-size:10.5px;color:#98a0aa;">{sub}</span></span></div>')
+
+    pct = lambda v: f"{round(100 * v / total)}%" if total else "0%"
+    summary = (
+        '<div style="border:1px solid #e6ebf1;border-radius:12px;padding:12px 14px;background:#fff;margin-top:12px;">'
+        '<div style="font-weight:700;color:#2b3a4a;font-size:13px;text-align:center;margin-bottom:2px;">Pipeline Summary</div>'
+        + "".join(_row(r, ph_tot[r], pct(ph_tot[r])) for r in rings)
+        + _row("Total", total, "Candidates", strong=True)
+        + f'<div style="margin-top:8px;font-size:10.5px;color:#98a0aa;text-align:center;">'
+          f'Showing: {html.escape(status_filter)} · {html.escape(mech_filter)}</div></div>')
+
+    subtitle = " &nbsp;|&nbsp; ".join(
+        f'{"Inner" if i == 0 else "Outer" if i == nr - 1 else "Middle"} ring: {html.escape(r)}'
+        for i, r in enumerate(rings))
+    return (
+        '<div style="font-family:-apple-system,Segoe UI,Roboto,sans-serif;">'
+        '<div style="text-align:center;margin-bottom:4px;">'
+        '<div style="font-size:21px;font-weight:800;color:#22303f;">ALS Therapeutic Pipeline by Clinical Trial Phase</div>'
+        f'<div style="font-size:13px;color:#8a929c;margin-top:2px;">{subtitle}</div></div>'
+        '<div style="display:flex;gap:18px;align-items:flex-start;justify-content:center;flex-wrap:wrap;">'
+        f'<div style="flex:1 1 460px;min-width:340px;max-width:720px;">{"".join(svg)}</div>'
+        f'<div style="flex:0 0 232px;width:232px;">{legend}{summary}</div>'
+        '</div></div>')
+
+
+# ── Mechanism → compound drill-down (drives the detail panel + trials table) ───
+
+def group_names(landscape: dict | None) -> list[str]:
+    """Display groups that have at least one compound, in canonical GROUP_ORDER."""
     if not landscape:
         return []
-    names = [c["name"] for c in landscape["classifications"]]
-    if landscape.get("unclassified"):
-        names.append(_INSUFFICIENT)
-    return names
+    present = {_group_of(t) for t in _all_compounds(landscape)}
+    return [g for g in GROUP_ORDER if g in present]
 
 
-def _therapies_of(landscape: dict, class_name: str) -> list[dict]:
-    if class_name == _INSUFFICIENT:
-        return landscape.get("unclassified", [])
-    for c in landscape["classifications"]:
-        if c["name"] == class_name:
-            return c["therapies"]
-    return []
+def mechanism_filter_options(landscape: dict | None) -> list[str]:
+    """Mechanism dropdown choices: 'All mechanisms' plus every group that has a compound."""
+    return [ALL_MECHANISMS] + group_names(landscape)
 
 
-def therapy_labels(landscape: dict | None, class_name: str, phases: list | None = None) -> list[str]:
-    """Dropdown labels, e.g. 'CNM-Au8 [contributing] — 5 trials, 3 recruiting'."""
-    sel = set(phases) if phases else None
-    labels = []
-    for t in _therapies_of(landscape or {}, class_name):
-        if not _therapy_matches_phases(t, sel):
+def compounds_of_group(landscape: dict | None, group: str,
+                       status_filter: str = "All trials", phases: list | None = None) -> list[dict]:
+    """Compounds in `group` (or all groups when group is ALL_MECHANISMS) with ≥1 passing trial."""
+    out = []
+    for t in _all_compounds(landscape or {}):
+        if group and group != ALL_MECHANISMS and _group_of(t) != group:
+            continue
+        if not _filter_trials(t.get("trials", []), status_filter, phases):
             continue
+        out.append(t)
+    return out
+
+
+def compound_labels(landscape: dict | None, group: str,
+                    status_filter: str = "All trials", phases: list | None = None) -> list[str]:
+    """Dropdown labels, e.g. 'Tofersen — 3 trials, 1 recruiting'."""
+    labels = []
+    for t in compounds_of_group(landscape, group, status_filter, phases):
         c = t["trial_counts"]
         rec = f", {c['recruiting']} recruiting" if c["recruiting"] else ""
-        role = t.get("role_here")
-        tag = f" [{role}]" if (role and class_name != _INSUFFICIENT) else ""
-        labels.append(f"{t['name']}{tag} — {c['total']} trial{'s' if c['total'] != 1 else ''}{rec}")
+        labels.append(f"{t['name']} — {c['total']} trial{'s' if c['total'] != 1 else ''}{rec}")
     return labels
 
 
-def _therapy_by_label(landscape: dict, class_name: str, label: str) -> dict | None:
-    name = label.split(" — ")[0].split(" [")[0] if label else ""
-    for t in _therapies_of(landscape, class_name):
+def _compound_by_label(landscape: dict | None, label: str) -> dict | None:
+    name = label.split(" — ")[0] if label else ""
+    if not name:
+        return None
+    for t in _all_compounds(landscape or {}):
         if t["name"] == name:
             return t
     return None
 
 
-def build_sunburst(landscape: dict | None, phases: list | None = None):
-    """Two-ring sunburst: inner = mechanism class, outer = its PRIMARY therapies (sized by trials).
-    Contributing memberships live in the detail panel; abstentions get an 'Insufficient evidence' wedge.
-    """
-    import plotly.graph_objects as go
-
-    sel = set(phases) if phases else None
-
-    def _keep(t):
-        return _therapy_matches_phases(t, sel)
-
-    ids, labels, parents, values, colors, hover = [], [], [], [], [], []
-
-    def add_class(name, therapies, color, desc=""):
-        if not therapies:
-            return
-        cid = f"cls::{name}"
-        total = sum(t["trial_counts"]["total"] for t in therapies)
-        ids.append(cid); labels.append(name); parents.append(""); values.append(total); colors.append(color)
-        hover.append(f"<b>{name}</b><br>{len(therapies)} therapies · {total} trials<br>{desc}")
-        for t in therapies:
-            cnt = t["trial_counts"]
-            ids.append(f"th::{name}::{t['name']}"); labels.append(t["name"]); parents.append(cid)
-            values.append(cnt["total"]); colors.append(color)
-            hover.append(f"<b>{t['name']}</b> ({t['modality']})<br>Target: {t['target']}<br>"
-                         f"{cnt['total']} trials · {cnt['recruiting']} recruiting · {cnt['completed']} completed")
-
-    if landscape:
-        for c in landscape["classifications"]:
-            primaries = [t for t in c["therapies"] if t.get("role_here") == "primary" and _keep(t)]
-            add_class(c["name"], primaries, _CLASS_COLORS.get(c["name"], _DEFAULT_COLOR), c.get("description", ""))
-        un = [t for t in landscape.get("unclassified", []) if _keep(t)]
-        if un:
-            add_class(_INSUFFICIENT, un, _CLASS_COLORS[_INSUFFICIENT],
-                      "Mechanism not established from available evidence")
-
-    fig = go.Figure(go.Sunburst(
-        ids=ids, labels=labels, parents=parents, values=values, branchvalues="total",
-        marker=dict(colors=colors), hovertext=hover, hoverinfo="text",
-        insidetextorientation="radial", maxdepth=2,
-    ))
-    fig.update_layout(margin=dict(t=10, l=0, r=0, b=0), height=520, paper_bgcolor="rgba(0,0,0,0)")
-    return fig
-
-
-def therapy_detail_md(landscape: dict | None, class_name: str, therapy_label: str) -> str:
-    if not landscape or not class_name:
-        return "*Select a mechanism class and therapy to see its mechanisms and trials.*"
-    t = _therapy_by_label(landscape, class_name, therapy_label)
+def compound_detail_md(landscape: dict | None, label: str) -> str:
+    if not landscape:
+        return "*Select a compound to see its pipeline stage and mechanisms.*"
+    t = _compound_by_label(landscape, label)
     if not t:
-        return f"*{class_name}* — select a therapy above."
-    header = f"### {t['name']}\n<sub>{t['modality']} · Target: {t['target']}</sub>"
+        return "*Select a compound above.*"
+    stage = _top_ring(t["trials"]) or "Preclinical / not applicable"
+    header = (f"### {t['name']}\n<sub>{t['modality']} · Target: {t['target']} · "
+              f"Pipeline stage: {stage}</sub>")
     if t.get("aliases"):
         header += f"\n<sub>Also: {', '.join(t['aliases'][:6])}</sub>"
     mechs = t.get("mechanisms") or []
@@ -169,17 +456,17 @@ def therapy_detail_md(landscape: dict | None, class_name: str, therapy_label: st
     return "\n".join(lines)
 
 
-def trials_table_html(landscape: dict | None, class_name: str, therapy_label: str) -> str:
-    if not landscape or not class_name:
+def compound_trials_html(landscape: dict | None, label: str) -> str:
+    if not landscape:
         return ""
-    t = _therapy_by_label(landscape, class_name, therapy_label)
+    t = _compound_by_label(landscape, label)
     if not t:
         return ""
     rows = []
     for tr in t["trials"]:
-        color, label = _STATUS_BADGE.get(tr["status_group"], _STATUS_BADGE["other"])
+        color, badge_label = _STATUS_BADGE.get(tr["status_group"], _STATUS_BADGE["other"])
         badge = (f'<span style="background:{color};color:#fff;border-radius:10px;'
-                 f'padding:1px 8px;font-size:0.72rem;white-space:nowrap;">{label}</span>')
+                 f'padding:1px 8px;font-size:0.72rem;white-space:nowrap;">{badge_label}</span>')
         phase = html.escape((tr.get("phase") or "—").replace("PHASE", "Ph"))
         title = html.escape(tr.get("title", "")[:110])
         nct = html.escape(tr.get("nct_id", ""))