medsci-skills 5.9.2 → 5.10.0

package/metadata/distribution_files.json

@@ -2003,8 +2003,8 @@
     },
     {
       "path": "skills/make-figures/references/exemplar_plots/README.md",
-      "size": 5872,
-      "sha256": "32f93f0c65b2fe353b17dd1345267c85d5646fcf7de7adb9f784be551fc900af"
+      "size": 6524,
+      "sha256": "6dded03ce2aa6cf81277d4a64fa15e0f6814aa568132fc817e2fc753517d5338"
     },
     {
       "path": "skills/make-figures/references/exemplar_plots/bland_altman.md",
@@ -2168,23 +2168,23 @@
     },
     {
       "path": "skills/make-figures/scripts/render_core_figures.py",
-      "size": 14436,
-      "sha256": "35f91147d51dd73b75dc116be9e0a80588fe1daf502966e82468d3c62b12f25d"
+      "size": 29667,
+      "sha256": "8c5b8a3b564b74977f25931094e11b55e2d1bad7ec6c05436825bd1bf69dc0b0"
     },
     {
       "path": "skills/make-figures/scripts/render_core_figures_challenge/fixture/synthetic_inputs.json",
-      "size": 1429,
-      "sha256": "24c0944fcb1384f073988d0f6e28b8f375ba4a7eff62fb4e21bc7066726d5ebc"
+      "size": 3609,
+      "sha256": "5ca97899b1f61fec1c933039fafdae13dbe20bec175561019a4c947109a9b88f"
     },
     {
       "path": "skills/make-figures/scripts/render_core_figures_challenge/problem.md",
-      "size": 2485,
-      "sha256": "a4e62161806d95b637d9ce984541190e5e9e213e2522d1f8740d847ee10c1a30"
+      "size": 3486,
+      "sha256": "86c57b26720a6ae1112a641f9ef1e1736c1bc3e413452de94d7e25ec298c26ba"
     },
     {
       "path": "skills/make-figures/scripts/render_core_figures_challenge/verify.sh",
-      "size": 1907,
-      "sha256": "7f05fd9cd4e2bfdf6c5b7e8e2a61bee5f8fd44d7d2746e29e2ae77adec84b9c0"
+      "size": 2378,
+      "sha256": "2961607318f21052d1b1e607b024520ac6a53ebf4afeaf4287199ed252c1c034"
     },
     {
       "path": "skills/make-figures/scripts/validate_pptx_mac_compat.py",

package/metadata/distribution_manifest.json

@@ -1,6 +1,6 @@
 {
   "schema_version": 1,
-  "version": "5.9.2",
+  "version": "5.10.0",
   "owned_skills": [
     "academic-aio",
     "add-journal",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medsci-skills",
-  "version": "5.9.2",
+  "version": "5.10.0",
   "description": "MedSci Skills — a medical/scientific research skill suite for AI coding agents (Claude Code, Codex, Cursor, Copilot). The npm package is a terminal-friendly installer shortcut; the canonical distribution remains the GitHub repository and the Claude Code plugin marketplace.",
   "license": "SEE LICENSE IN LICENSE",
   "homepage": "https://github.com/Aperivue/medsci-skills#readme",

package/skills/make-figures/references/exemplar_plots/README.md

@@ -13,15 +13,24 @@ against `critic_rubrics/data_plot.md`; do not copy an image.
 
 ## Runnable render layer (tested)
 
-For the four highest-yield clinical figures — **Kaplan–Meier, ROC, calibration, and
-decision-curve** — the prose anatomy here has a matching **runnable, deterministic
-generator** in `../../scripts/render_core_figures.py`. It renders already-computed inputs
+Ten of the highest-yield clinical figures — **Kaplan–Meier, ROC, calibration,
+decision-curve, forest, Bland–Altman, confusion matrix, multi-reader ROC (MRMC),
+Manhattan, and clinical timeline** — have a matching **runnable, deterministic generator**
+in `../../scripts/render_core_figures.py`. It renders already-computed inputs
 (the statistical estimation stays in `/analyze-stats`; the render layer never recomputes a
 number) into the canonical anatomy and asserts each figure's load-bearing elements
 (number-at-risk table, chance diagonal, identity line, treat-all/treat-none references,
-no extrapolation past follow-up). A network-free render-regression challenge
+no extrapolation past follow-up; forest per-study CI rows + null line + pooled diamond;
+Bland–Altman bias + 95% limits of agreement; confusion Predicted/Actual axes + annotated
+cells; MRMC per-reader + averaged curves; Manhattan significance-threshold line; timeline
+baseline + event markers). A network-free render-regression challenge
 (`scripts/render_core_figures_challenge/`, wired into `skill.yml` validation) renders all
-four from a synthetic fixture and confirms the structural gate fails on a malformed figure.
+ten from a synthetic fixture and confirms the structural gate fails on a malformed figure.
+
+`imaging_panel.md` stays a **prose-only** exemplar by design: it composes real medical
+images with panel labels, scale bars, and arrows — an image-arrangement task, not a plot of
+computed numbers — so a synthetic generator would only draw placeholder boxes. Use the
+prose model to compose it against real images.
 Use the generator to produce these four directly; use the prose models below to compose
 the figure types that do not yet have a generator.
 

package/skills/make-figures/scripts/render_core_figures.py

@@ -33,6 +33,7 @@ import matplotlib
 matplotlib.use("Agg")  # headless, deterministic
 import matplotlib.pyplot as plt  # noqa: E402
 import numpy as np  # noqa: E402
+from matplotlib.patches import Polygon  # noqa: E402
 
 
 # --------------------------------------------------------------------------- KM
@@ -164,6 +165,188 @@ def decision_curve(thresholds, net_benefit_model, prevalence: float, *,
     return fig
 
 
+# ------------------------------------------------------------------- forest
+def forest_plot(studies: list[dict], pooled: dict, *, null_value: float = 1.0,
+                effect_label: str = "Effect (95% CI)", title: str = "",
+                log_x: bool = True) -> plt.Figure:
+    """Meta-analysis forest plot from already-computed per-study estimates.
+
+    studies: [{name, est, lo, hi, weight?}] — each study's point estimate + CI.
+    pooled:  {est, lo, hi, label}          — the pooled estimate + CI + model name.
+    Draws a weight-scaled marker + CI whisker per study, the null reference line, and a
+    pooled diamond; the pooled row is always last. For a ratio measure keep log_x=True and
+    null_value=1.0; for a mean difference pass log_x=False, null_value=0.0."""
+    n = len(studies)
+    fig, ax = plt.subplots(figsize=(6.6, 0.5 * n + 2.0))
+    ys = list(range(n, 0, -1))  # top study at the highest y
+    weights = np.asarray([s.get("weight", 1.0) for s in studies], float)
+    wnorm = weights / weights.max() if weights.max() > 0 else np.ones(n)
+    for y, s, w in zip(ys, studies, wnorm):
+        ax.plot([s["lo"], s["hi"]], [y, y], color="0.3")             # CI whisker
+        ax.scatter([s["est"]], [y], s=30 + 120 * w, marker="s",
+                   color="steelblue", zorder=4)                       # weight-scaled box
+    ax.axvline(null_value, linestyle="--", color="0.5")               # null reference
+    # pooled diamond on a row below the studies
+    yd = 0
+    d = pooled
+    ax.add_patch(Polygon([[d["lo"], yd], [d["est"], yd + 0.35],
+                          [d["hi"], yd], [d["est"], yd - 0.35]],
+                         closed=True, facecolor="crimson", edgecolor="black", zorder=5))
+    labels = [s["name"] for s in studies] + [pooled.get("label", "Pooled")]
+    ax.set_yticks(ys + [yd])
+    ax.set_yticklabels(labels)
+    ax.set_ylim(-1, n + 1)
+    if log_x:
+        ax.set_xscale("log")
+    ax.set_xlabel(effect_label)
+    ax.set_title(title or "Meta-analysis forest plot")
+    fig.tight_layout()
+    fig._mf_kind = "forest"
+    fig._mf_n_studies = n
+    fig._mf_null = null_value
+    return fig
+
+
+# -------------------------------------------------------------- Bland–Altman
+def bland_altman(mean_vals, diff_vals, *, bias: float, sd_diff: float,
+                 title: str = "") -> plt.Figure:
+    """Bland–Altman agreement plot: difference vs mean, with the bias line and the
+    95% limits of agreement (bias ± 1.96·SD) — the load-bearing agreement elements."""
+    mean_vals = np.asarray(mean_vals, float)
+    diff_vals = np.asarray(diff_vals, float)
+    loa_hi, loa_lo = bias + 1.96 * sd_diff, bias - 1.96 * sd_diff
+    fig, ax = plt.subplots(figsize=(6.0, 5.0))
+    ax.scatter(mean_vals, diff_vals, s=25, color="steelblue", alpha=0.8)
+    ax.axhline(bias, color="crimson", label=f"Bias {bias:.2f}")
+    ax.axhline(loa_hi, linestyle="--", color="0.4", label=f"+1.96 SD {loa_hi:.2f}")
+    ax.axhline(loa_lo, linestyle="--", color="0.4", label=f"−1.96 SD {loa_lo:.2f}")
+    ax.set_xlabel("Mean of the two measurements")
+    ax.set_ylabel("Difference between measurements")
+    ax.set_title(title or "Bland–Altman agreement")
+    ax.legend(loc="upper right", frameon=False)
+    fig.tight_layout()
+    fig._mf_kind = "bland_altman"
+    fig._mf_loa = (loa_lo, loa_hi)
+    return fig
+
+
+# ---------------------------------------------------------- confusion matrix
+def confusion_matrix(matrix, labels, *, title: str = "") -> plt.Figure:
+    """Confusion matrix from an already-computed count grid. Rows = actual, cols =
+    predicted; every cell is annotated with its count (for a 2×2, TN/FP/FN/TP)."""
+    m = np.asarray(matrix, float)
+    k = m.shape[0]
+    if m.shape[0] != m.shape[1] or k != len(labels):
+        raise AssertionError("confusion matrix must be square and match the label count")
+    fig, ax = plt.subplots(figsize=(1.4 * k + 2, 1.4 * k + 2))
+    ax.imshow(m, cmap="Blues")
+    thresh = m.max() / 2.0 if m.max() else 0.5
+    for i in range(k):
+        for j in range(k):
+            ax.text(j, i, str(int(m[i, j])), ha="center", va="center",
+                    color="white" if m[i, j] > thresh else "black")
+    ax.set_xticks(range(k)); ax.set_xticklabels(labels)
+    ax.set_yticks(range(k)); ax.set_yticklabels(labels)
+    ax.set_xlabel("Predicted")
+    ax.set_ylabel("Actual")
+    ax.set_title(title or "Confusion matrix")
+    fig.tight_layout()
+    fig._mf_kind = "confusion"
+    fig._mf_k = k
+    return fig
+
+
+# ------------------------------------------------------------------ MRMC ROC
+def mrmc_roc(readers: list[dict], averaged: dict, *, delta_auc: dict | None = None,
+             title: str = "") -> plt.Figure:
+    """Multi-reader multi-case ROC: each reader's ROC curve plus the reader-averaged
+    curve and the chance diagonal (the load-bearing MRMC-reader-study elements).
+
+    readers:  [{name, fpr, tpr, auc}]  — per-reader ROC coordinates.
+    averaged: {fpr, tpr, auc, label}   — the reader-averaged curve.
+    delta_auc (optional): {value, margin} — a ΔAUC-vs-margin annotation."""
+    fig, ax = plt.subplots(figsize=(5.4, 5.2))
+    for r in readers:
+        ax.plot(np.asarray(r["fpr"], float), np.asarray(r["tpr"], float),
+                color="0.7", linewidth=1)                              # thin per-reader
+    a = averaged
+    ax.plot(np.asarray(a["fpr"], float), np.asarray(a["tpr"], float),
+            color="crimson", linewidth=2.4,
+            label=f"{a.get('label', 'Reader-averaged')} (AUC = {a['auc']:.3f})")
+    ax.plot([0, 1], [0, 1], linestyle="--", color="0.5", label="Chance")
+    ax.set_xlim(0, 1); ax.set_ylim(0, 1.02)
+    ax.set_xlabel("1 − specificity (false-positive rate)")
+    ax.set_ylabel("Sensitivity (true-positive rate)")
+    ax.set_title(title or "Multi-reader multi-case ROC")
+    txt = f"averaged AUC = {a['auc']:.3f}"
+    if delta_auc:
+        txt += f"\nΔAUC = {delta_auc['value']:.3f} (margin {delta_auc['margin']:.3f})"
+    ax.text(0.55, 0.08, txt, fontsize=10,
+            bbox=dict(boxstyle="round", fc="white", ec="0.7"))
+    ax.legend(loc="lower right", frameon=False)
+    fig.tight_layout()
+    fig._mf_kind = "mrmc_roc"
+    fig._mf_n_readers = len(readers)
+    return fig
+
+
+# ------------------------------------------------------------------ Manhattan
+def manhattan(x, neglogp, threshold: float, *, labels=None,
+              ylabel: str = "−log10(p)", xlabel: str = "Exposure / position",
+              title: str = "") -> plt.Figure:
+    """Manhattan / *-wide-scan plot: −log10(p) vs position with the significance
+    threshold line (the two load-bearing elements of an agnostic many-test scan)."""
+    x = np.asarray(x, float)
+    y = np.asarray(neglogp, float)
+    fig, ax = plt.subplots(figsize=(7.0, 4.4))
+    ax.scatter(x, y, s=14, color="steelblue", alpha=0.8)
+    ax.axhline(threshold, color="crimson", linestyle="--",
+               label=f"significance threshold (−log10 = {threshold:.2f})")
+    if labels:  # sparse labelling of hits above the threshold
+        for xi, yi, lab in zip(x, y, labels):
+            if lab and yi >= threshold:
+                ax.annotate(lab, (xi, yi), fontsize=8,
+                            xytext=(0, 4), textcoords="offset points", ha="center")
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.set_title(title or "Manhattan plot")
+    ax.legend(loc="upper right", frameon=False)
+    fig.tight_layout()
+    fig._mf_kind = "manhattan"
+    fig._mf_threshold = threshold
+    return fig
+
+
+# --------------------------------------------------------- clinical timeline
+def clinical_timeline(events: list[dict], *, time_unit: str = "days from admission",
+                      title: str = "") -> plt.Figure:
+    """Case-report clinical timeline: an event marker + label at each time on a single
+    time axis (the load-bearing elements of a longitudinal case figure)."""
+    times = [float(e["time"]) for e in events]
+    fig, ax = plt.subplots(figsize=(max(6.0, 0.9 * len(events)), 3.4))
+    lo, hi = (min(times), max(times)) if times else (0, 1)
+    pad = max(1.0, (hi - lo) * 0.08)
+    ax.axhline(0, color="0.4")                                        # the timeline
+    for i, e in enumerate(events):
+        t = float(e["time"])
+        up = 1 if i % 2 == 0 else -1
+        ax.plot([t, t], [0, up * 0.6], color="0.6")                  # stem
+        ax.scatter([t], [0], s=40, color="crimson", zorder=5)         # event marker
+        ax.annotate(str(e["label"]), (t, up * 0.65), ha="center",
+                    va="bottom" if up > 0 else "top", fontsize=8)
+    ax.set_xlim(lo - pad, hi + pad)
+    ax.set_ylim(-1.3, 1.3)
+    ax.get_yaxis().set_visible(False)
+    for spine in ("left", "right", "top"):
+        ax.spines[spine].set_visible(False)
+    ax.set_xlabel(f"Time ({time_unit})")
+    ax.set_title(title or "Clinical timeline")
+    fig.tight_layout()
+    fig._mf_kind = "timeline"
+    fig._mf_n_events = len(events)
+    return fig
+
+
 # ----------------------------------------------------- structural invariants
 def assert_structure(fig: plt.Figure) -> list[str]:
     """Assert the load-bearing elements for the figure's kind. Returns the list of
@@ -241,6 +424,97 @@ def assert_structure(fig: plt.Figure) -> list[str]:
             "DCA: treat-all / treat-none not labelled"
         passed.append("DCA reference strategies labelled")
 
+    elif kind == "forest":
+        ax = fig.axes[0]
+        n = getattr(fig, "_mf_n_studies")
+        # one horizontal CI whisker (2-point line, equal y) per study
+        whiskers = [ln for ln in ax.lines
+                    if len(ln.get_xdata()) == 2 and np.allclose(np.diff(ln.get_ydata()), 0.0)]
+        assert len(whiskers) >= n, "forest: missing per-study CI whiskers"
+        passed.append(f"forest per-study CI rows present ({n})")
+        null = getattr(fig, "_mf_null")
+        assert any(len(ln.get_xdata()) == 2 and np.allclose(ln.get_xdata(), [null, null])
+                   for ln in ax.lines), "forest: null reference line missing"
+        passed.append("forest null reference line present")
+        assert any(isinstance(p, Polygon) and len(p.get_xy()) >= 4 for p in ax.patches), \
+            "forest: pooled diamond missing"
+        passed.append("forest pooled diamond present")
+        assert len(ax.get_yticklabels()) >= n + 1, "forest: study/pooled row labels missing"
+        passed.append("forest study + pooled row labels present")
+
+    elif kind == "bland_altman":
+        ax = fig.axes[0]
+        assert ax.collections, "Bland–Altman: scatter of differences missing"
+        passed.append("Bland–Altman difference scatter present")
+        hlines = [ln for ln in ax.lines if np.allclose(np.diff(ln.get_ydata()), 0.0)]
+        assert len(hlines) >= 3, "Bland–Altman: need bias + two limits-of-agreement lines"
+        passed.append("Bland–Altman bias + 2 LoA lines present")
+        loa_lo, loa_hi = getattr(fig, "_mf_loa")
+        yvals = [float(ln.get_ydata()[0]) for ln in hlines]
+        assert any(abs(y - loa_hi) < 1e-6 for y in yvals) and any(abs(y - loa_lo) < 1e-6 for y in yvals), \
+            "Bland–Altman: LoA lines not at bias ± 1.96·SD"
+        passed.append("Bland–Altman LoA at bias ± 1.96·SD")
+        assert "difference" in ax.get_ylabel().lower() and "mean" in ax.get_xlabel().lower(), \
+            "Bland–Altman: axes not difference-vs-mean"
+        passed.append("Bland–Altman difference-vs-mean axes")
+
+    elif kind == "confusion":
+        ax = fig.axes[0]
+        k = getattr(fig, "_mf_k")
+        assert ax.images, "confusion: matrix image missing"
+        passed.append("confusion matrix image present")
+        cells = [t for t in ax.texts if t.get_text().strip().lstrip("-").isdigit()]
+        assert len(cells) >= k * k, f"confusion: expected {k * k} annotated cells"
+        passed.append(f"confusion all {k}×{k} cells annotated")
+        assert "predicted" in ax.get_xlabel().lower() and "actual" in ax.get_ylabel().lower(), \
+            "confusion: axes not Predicted/Actual"
+        passed.append("confusion Predicted/Actual axes")
+
+    elif kind == "mrmc_roc":
+        ax = fig.axes[0]
+        n = getattr(fig, "_mf_n_readers")
+        curves = [ln for ln in ax.lines
+                  if len(ln.get_xdata()) > 2]                          # multi-point ROC curves
+        assert len(curves) >= n + 1, "MRMC-ROC: fewer curves than readers + averaged"
+        passed.append(f"MRMC-ROC per-reader + averaged curves present ({n}+1)")
+        diag = [ln for ln in ax.lines
+                if len(ln.get_xdata()) == 2 and np.allclose(ln.get_xdata(), [0, 1])
+                and np.allclose(ln.get_ydata(), [0, 1])]
+        assert diag, "MRMC-ROC: chance diagonal missing"
+        passed.append("MRMC-ROC chance diagonal present")
+        assert has_text(ax, "auc"), "MRMC-ROC: averaged-AUC annotation missing"
+        passed.append("MRMC-ROC averaged-AUC annotation present")
+        assert "sensitiv" in ax.get_ylabel().lower(), "MRMC-ROC: y-label not sensitivity"
+        passed.append("MRMC-ROC sensitivity y-label")
+
+    elif kind == "manhattan":
+        ax = fig.axes[0]
+        assert ax.collections, "Manhattan: point scatter missing"
+        passed.append("Manhattan scatter present")
+        thr = getattr(fig, "_mf_threshold")
+        assert any(np.allclose(ln.get_ydata(), thr) for ln in ax.lines
+                   if np.allclose(np.diff(ln.get_ydata()), 0.0)), \
+            "Manhattan: significance threshold line missing"
+        passed.append("Manhattan significance threshold line present")
+        yl = ax.get_ylabel().lower()
+        assert "log" in yl and ("10" in yl or "log10" in yl or "−log" in yl or "-log" in yl), \
+            "Manhattan: y-label not −log10(p)"
+        passed.append("Manhattan −log10(p) y-label")
+
+    elif kind == "timeline":
+        ax = fig.axes[0]
+        ne = getattr(fig, "_mf_n_events")
+        assert any(np.allclose(ln.get_ydata(), 0.0) for ln in ax.lines), \
+            "timeline: baseline axis missing"
+        passed.append("timeline baseline present")
+        assert ax.collections, "timeline: event markers missing"
+        passed.append("timeline event markers present")
+        assert len([t for t in ax.texts if t.get_text().strip()]) >= ne, \
+            "timeline: an event label is missing"
+        passed.append(f"timeline all {ne} event labels present")
+        assert "time" in ax.get_xlabel().lower(), "timeline: x-axis not a time axis"
+        passed.append("timeline time x-axis")
+
     else:
         raise AssertionError(f"unknown figure kind: {kind!r}")
     return passed
@@ -248,7 +522,7 @@ def assert_structure(fig: plt.Figure) -> list[str]:
 
 # ----------------------------------------------------------------- driver
 def render_all(inputs: dict, out_dir: Path) -> dict:
-    """Render all four figures from ``inputs``, save PNGs, and assert structure.
+    """Render each figure kind present in ``inputs``, save PNGs, and assert structure.
     Returns {kind: [passed checks]}. Raises on any structural violation."""
     out_dir.mkdir(parents=True, exist_ok=True)
     results: dict[str, list[str]] = {}
@@ -261,6 +535,20 @@ def render_all(inputs: dict, out_dir: Path) -> dict:
             ci_low=d.get("ci_low"), ci_high=d.get("ci_high")),
         "dca": lambda d: decision_curve(d["thresholds"], d["net_benefit_model"],
                                         d["prevalence"]),
+        "forest": lambda d: forest_plot(d["studies"], d["pooled"],
+                                        null_value=d.get("null_value", 1.0),
+                                        effect_label=d.get("effect_label", "Effect (95% CI)"),
+                                        log_x=d.get("log_x", True)),
+        "bland_altman": lambda d: bland_altman(d["mean_vals"], d["diff_vals"],
+                                               bias=d["bias"], sd_diff=d["sd_diff"]),
+        "confusion": lambda d: confusion_matrix(d["matrix"], d["labels"]),
+        "mrmc_roc": lambda d: mrmc_roc(d["readers"], d["averaged"],
+                                       delta_auc=d.get("delta_auc")),
+        "manhattan": lambda d: manhattan(d["x"], d["neglogp"], d["threshold"],
+                                         labels=d.get("labels"),
+                                         xlabel=d.get("xlabel", "Exposure / position")),
+        "timeline": lambda d: clinical_timeline(d["events"],
+                                                time_unit=d.get("time_unit", "days from admission")),
     }
     for kind, build in builders.items():
         if kind not in inputs:
@@ -287,7 +575,7 @@ def main(argv=None) -> int:
         return 1
     for kind, checks in results.items():
         print(f"OK [{kind}] {len(checks)} structural invariants: {'; '.join(checks)}")
-    print(f"PASS: {len(results)}/4 core figures rendered + structurally verified.")
+    print(f"PASS: {len(results)} figure(s) rendered + structurally verified.")
     return 0
 
 

package/skills/make-figures/scripts/render_core_figures_challenge/fixture/synthetic_inputs.json

@@ -38,5 +38,54 @@
     "thresholds": [0.05, 0.10, 0.20, 0.30, 0.40, 0.50],
     "net_benefit_model": [0.34, 0.30, 0.22, 0.15, 0.09, 0.04],
     "prevalence": 0.35
+  },
+  "forest": {
+    "effect_label": "Odds ratio (95% CI)",
+    "null_value": 1.0,
+    "log_x": true,
+    "studies": [
+      {"name": "Study A 2019", "est": 1.20, "lo": 0.90, "hi": 1.60, "weight": 25},
+      {"name": "Study B 2020", "est": 1.45, "lo": 1.10, "hi": 1.92, "weight": 30},
+      {"name": "Study C 2021", "est": 0.95, "lo": 0.70, "hi": 1.29, "weight": 20},
+      {"name": "Study D 2022", "est": 1.60, "lo": 1.15, "hi": 2.22, "weight": 25}
+    ],
+    "pooled": {"est": 1.30, "lo": 1.10, "hi": 1.54, "label": "Random-effects pooled"}
+  },
+  "bland_altman": {
+    "mean_vals": [10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32],
+    "diff_vals": [0.2, -0.5, 0.8, 1.1, -0.3, 0.6, -1.2, 0.9, 0.1, 1.5, -0.7, 0.4],
+    "bias": 0.24,
+    "sd_diff": 0.80
+  },
+  "confusion": {
+    "matrix": [[85, 15], [10, 90]],
+    "labels": ["Negative", "Positive"]
+  },
+  "mrmc_roc": {
+    "readers": [
+      {"name": "Reader 1", "fpr": [0.0, 0.10, 0.25, 0.50, 1.0], "tpr": [0.0, 0.55, 0.72, 0.88, 1.0], "auc": 0.80},
+      {"name": "Reader 2", "fpr": [0.0, 0.08, 0.20, 0.45, 1.0], "tpr": [0.0, 0.62, 0.78, 0.90, 1.0], "auc": 0.84},
+      {"name": "Reader 3", "fpr": [0.0, 0.12, 0.30, 0.55, 1.0], "tpr": [0.0, 0.50, 0.68, 0.85, 1.0], "auc": 0.77}
+    ],
+    "averaged": {"fpr": [0.0, 0.10, 0.25, 0.50, 1.0], "tpr": [0.0, 0.56, 0.73, 0.88, 1.0], "auc": 0.805, "label": "Reader-averaged"},
+    "delta_auc": {"value": 0.06, "margin": 0.05}
+  },
+  "manhattan": {
+    "xlabel": "Candidate exposure (index)",
+    "threshold": 2.6,
+    "x": [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20],
+    "neglogp": [0.4, 1.2, 0.8, 3.5, 0.6, 1.1, 2.1, 0.9, 4.2, 0.5, 1.3, 0.7, 2.8, 1.0, 0.4, 5.1, 0.9, 1.4, 0.6, 2.2],
+    "labels": ["", "", "", "Exposure D", "", "", "", "", "Exposure I", "", "", "", "Exposure M", "", "", "Exposure P", "", "", "", ""]
+  },
+  "timeline": {
+    "time_unit": "days from admission",
+    "events": [
+      {"time": 0, "label": "Admission"},
+      {"time": 2, "label": "CT scan"},
+      {"time": 5, "label": "Biopsy"},
+      {"time": 9, "label": "Diagnosis"},
+      {"time": 14, "label": "Treatment start"},
+      {"time": 30, "label": "Follow-up"}
+    ]
   }
 }

package/skills/make-figures/scripts/render_core_figures_challenge/problem.md

@@ -1,15 +1,17 @@
 # Challenge card — core clinical-figure render regression (make-figures)
 
 ## Problem
-The four highest-yield clinical figures — Kaplan–Meier, ROC, calibration, and
-decision-curve — were documented only as **prose anatomy** in
+The highest-yield clinical figures — Kaplan–Meier, ROC, calibration, decision-curve,
+forest, Bland–Altman, and confusion matrix — were documented only as **prose anatomy** in
 `references/exemplar_plots/`, and the actual matplotlib rendering had **no deterministic
 test of any kind**. A regression in figure code (a dropped number-at-risk table, a
 missing chance diagonal, a calibration plot without its identity line, a DCA without the
-treat-all / treat-none references, or a KM curve extrapolated past follow-up) would pass
-every prose read and only be caught by a reviewer — the gap that left the suite's
-self-identified weakest area with the same defense/enablement asymmetry the rest of the
-repo has closed (42 integrity detectors vs ~0 generative render tests).
+treat-all / treat-none references, a KM curve extrapolated past follow-up, a forest without
+its pooled diamond or null line, a Bland–Altman without its limits of agreement, or a
+confusion matrix without annotated cells) would pass every prose read and only be caught by
+a reviewer — the gap that left the suite's self-identified weakest area with the same
+defense/enablement asymmetry the rest of the repo has closed (integrity detectors have
+challenge fixtures; the figure generators did not).
 
 ## What the generator does
 `scripts/render_core_figures.py` is the **render** layer for the exemplar anatomies. It
@@ -26,17 +28,31 @@ elements are present:
   predicted-vs-observed axes.
 - **Decision curve** — model + treat-all + treat-none strategies, the treat-none
   (net benefit = 0) reference, a net-benefit y-axis.
+- **Forest** — a per-study CI whisker for every study, the null reference line, and the
+  pooled diamond; study + pooled row labels.
+- **Bland–Altman** — the difference scatter, the bias line, and the 95% limits of
+  agreement (bias ± 1.96·SD); difference-vs-mean axes.
+- **Confusion matrix** — a matrix image with every cell annotated and Predicted/Actual axes.
+- **MRMC ROC** — a curve per reader + the reader-averaged curve, the chance diagonal, and
+  the averaged-AUC annotation.
+- **Manhattan** — the point scatter, the named significance-threshold line, and a
+  −log10(p) y-axis.
+- **Clinical timeline** — the time baseline, an event marker + label at each event, and a
+  time x-axis.
+
+(`imaging_panel` stays a prose-only exemplar — it composes real images, not computed
+numbers, so it has no synthetic generator.)
 
 ## Fixture (synthetic only — no real data)
-- `fixture/synthetic_inputs.json` — hand-authored step/curve coordinates and summary
-  statistics for all four figures.
+- `fixture/synthetic_inputs.json` — hand-authored coordinates and summary statistics for
+  all ten figures.
 
 ## Expected (`verify.sh`, network-free)
-- All four figures render to PNGs (each > 2 KB) **and** every structural invariant holds
+- All ten figures render to PNGs (each > 2 KB) **and** every structural invariant holds
   → exit 0.
-- A mutated input that drops a load-bearing element (e.g. a KM curve extended past
-  follow-up, or a DCA missing the treat-none reference) raises `AssertionError` → the
-  negative cases in `verify.sh` confirm the gate actually fails when it should.
+- Mutated inputs that drop a load-bearing element (a non-monotonic KM curve; a non-square
+  confusion matrix) raise `AssertionError` → the negative cases in `verify.sh` confirm the
+  gate actually fails when it should.
 
 Requires matplotlib + numpy (already make-figures runtime deps); the verifier skips with
 a clear message if matplotlib is unavailable, so it never hard-fails a minimal host.

package/skills/make-figures/scripts/render_core_figures_challenge/verify.sh

@@ -1,8 +1,8 @@
 #!/usr/bin/env bash
 # Deterministic verifier for the core-figure render challenge (make-figures).
-# Network-free. Renders the four canonical clinical figures from a synthetic fixture and
+# Network-free. Renders the ten canonical clinical figures from a synthetic fixture and
 # asserts each figure's load-bearing elements; then confirms the structural gate FAILS on
-# a mutated input (so the assertions are proven to bite). Exit 0 = all expectations hold.
+# mutated inputs (so the assertions are proven to bite). Exit 0 = all expectations hold.
 set -euo pipefail
 HERE="$(cd "$(dirname "$0")" && pwd)"
 GEN="$HERE/../render_core_figures.py"
@@ -13,25 +13,34 @@ TMP="$(mktemp -d)"; trap 'rm -rf "$TMP"' EXIT
 python3 -c "import matplotlib, numpy" 2>/dev/null \
   || { echo "SKIP: matplotlib/numpy unavailable on this host"; exit 0; }
 
-# (1) Positive: all four figures render + every structural invariant holds.
+# (1) Positive: all ten figures render + every structural invariant holds.
 python3 "$GEN" --inputs "$FIX" --out-dir "$TMP/out" >"$TMP/log" 2>&1 \
   || { echo "FAIL: valid fixture did not render/verify" >&2; cat "$TMP/log" >&2; exit 1; }
-for k in km roc calibration dca; do
+for k in km roc calibration dca forest bland_altman confusion mrmc_roc manhattan timeline; do
   [ -s "$TMP/out/$k.png" ] || { echo "FAIL: $k.png not written" >&2; exit 1; }
 done
-grep -q "PASS: 4/4" "$TMP/log" || { echo "FAIL: not all four figures verified" >&2; cat "$TMP/log" >&2; exit 1; }
+grep -q "PASS: 10 figure" "$TMP/log" || { echo "FAIL: not all ten figures verified" >&2; cat "$TMP/log" >&2; exit 1; }
 
-# (2) Negative: a KM survival curve mutated to be non-monotonic must make the structural
-# gate FAIL — proves the load-bearing-element assertions actually fire.
-python3 - "$FIX" "$TMP/bad.json" <<'PY'
+# (2) Negative — the assertions must actually fire on malformed inputs.
+# (2a) a KM survival curve mutated to be non-monotonic.
+python3 - "$FIX" "$TMP/bad_km.json" <<'PY'
 import json, sys
 d = json.load(open(sys.argv[1]))
 d["km"]["groups"][0]["surv"] = [1.0, 0.92, 0.95, 0.74, 0.68]  # 0.81 -> 0.95 (increasing)
 json.dump(d, open(sys.argv[2], "w"))
 PY
-if python3 "$GEN" --inputs "$TMP/bad.json" --out-dir "$TMP/bad" >/dev/null 2>&1; then
-  echo "FAIL: a non-monotonic KM survival curve was NOT caught by the structural gate" >&2
-  exit 1
+if python3 "$GEN" --inputs "$TMP/bad_km.json" --out-dir "$TMP/bk" >/dev/null 2>&1; then
+  echo "FAIL: a non-monotonic KM survival curve was NOT caught" >&2; exit 1
+fi
+# (2b) a non-square confusion matrix (label/shape mismatch).
+python3 - "$FIX" "$TMP/bad_cm.json" <<'PY'
+import json, sys
+d = json.load(open(sys.argv[1]))
+d["confusion"]["matrix"] = [[85, 15, 0], [10, 90, 0]]  # 2x3, not square
+json.dump(d, open(sys.argv[2], "w"))
+PY
+if python3 "$GEN" --inputs "$TMP/bad_cm.json" --out-dir "$TMP/bc" >/dev/null 2>&1; then
+  echo "FAIL: a non-square confusion matrix was NOT caught" >&2; exit 1
 fi
 
-echo "PASS: 4/4 core figures render + structurally verify; the gate fails on a non-monotonic KM curve."
+echo "PASS: 10 core figures render + structurally verify; the gate fails on a non-monotonic KM curve and a non-square confusion matrix."