medsci-skills 5.9.2 → 5.11.0

package/metadata/distribution_files.json

@@ -1658,8 +1658,8 @@
     },
     {
       "path": "skills/humanize/SKILL.md",
-      "size": 13461,
-      "sha256": "78e12b996cacfa5b1b16b0a0fe26cee5dd72cb990b70f26e90041d6e0eb65c9a"
+      "size": 14240,
+      "sha256": "f179598c74b1ab0b3d6639fdd26b8cafa33713a9ebe9374aad5d31571340d836"
     },
     {
       "path": "skills/humanize/references/ai_patterns.md",
@@ -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",
@@ -2923,8 +2923,8 @@
     },
     {
       "path": "skills/peer-review/SKILL.md",
-      "size": 68213,
-      "sha256": "51feccb82dca34a28a0b9ace5467d23ddc654056af2cd9e152a4559cf074cfc3"
+      "size": 68302,
+      "sha256": "bf56fbc16bb3e43fb43f09982d36e68f53f8b0f666564e2828e692472ad0660f"
     },
     {
       "path": "skills/peer-review/references/aczel_2021_reviewer2_patterns.md",
@@ -2933,8 +2933,8 @@
     },
     {
       "path": "skills/peer-review/references/domain-probes/ai_overclaiming.md",
-      "size": 14205,
-      "sha256": "565aa362e20ea6ca923510ea393829fb851e0caaae3d732f99144dd48a25b951"
+      "size": 15410,
+      "sha256": "bdb07002bf0b351579036937af5bf149e35389a218198699b81d31dc2fda7ec9"
     },
     {
       "path": "skills/peer-review/references/domain-probes/case_report.md",
@@ -2948,8 +2948,8 @@
     },
     {
       "path": "skills/peer-review/references/domain-probes/diagnostic_accuracy.md",
-      "size": 9002,
-      "sha256": "8232e2023d3c4d52e6a2d9003ae335302d6fe78c54d39b81f591c07becaf4df0"
+      "size": 11692,
+      "sha256": "afc69e56578babcc1cf7c7952d2df301fdc829329fb480a5cf426ff6ab65d9f5"
     },
     {
       "path": "skills/peer-review/references/domain-probes/equity_fairness.md",
@@ -2993,8 +2993,8 @@
     },
     {
       "path": "skills/peer-review/references/domain-probes/observational_confounding.md",
-      "size": 33429,
-      "sha256": "ac1736047c069aa47df76deea92379cae407043b6989d8d3fc77db8fd84b0031"
+      "size": 34617,
+      "sha256": "ec4a11caed6d604e510437827f2b979fcf43ab1ddea6b298eb95673472b2b459"
     },
     {
       "path": "skills/peer-review/references/domain-probes/polygenic_risk_score.md",
@@ -3028,8 +3028,8 @@
     },
     {
       "path": "skills/peer-review/references/domain-probes/sr_ma.md",
-      "size": 17239,
-      "sha256": "486d569f559f16d62b882f7256ccfe7443e3e2b4cc72a407a5cd046162a98b25"
+      "size": 20154,
+      "sha256": "82ccb4abc1ab1fffaf528268baad6c79e67c9b2ff929c14d7dcccb9677e10ddc"
     },
     {
       "path": "skills/peer-review/references/domain-probes/survey_research.md",
@@ -3488,13 +3488,13 @@
     },
     {
       "path": "skills/self-review/SKILL.md",
-      "size": 102413,
-      "sha256": "97219c57684d4eaced9e35b0968ca09da7731095c186a4e97757b4039f43f2f6"
+      "size": 104028,
+      "sha256": "22bc51c9adcb1fc9ff9120c2650faaa2f5f3a0482fe1fd781e231e2191e21081"
     },
     {
       "path": "skills/self-review/references/domain-probes/ai_overclaiming.md",
-      "size": 14205,
-      "sha256": "565aa362e20ea6ca923510ea393829fb851e0caaae3d732f99144dd48a25b951"
+      "size": 15410,
+      "sha256": "bdb07002bf0b351579036937af5bf149e35389a218198699b81d31dc2fda7ec9"
     },
     {
       "path": "skills/self-review/references/domain-probes/case_report.md",
@@ -3508,8 +3508,8 @@
     },
     {
       "path": "skills/self-review/references/domain-probes/diagnostic_accuracy.md",
-      "size": 9002,
-      "sha256": "8232e2023d3c4d52e6a2d9003ae335302d6fe78c54d39b81f591c07becaf4df0"
+      "size": 11692,
+      "sha256": "afc69e56578babcc1cf7c7952d2df301fdc829329fb480a5cf426ff6ab65d9f5"
     },
     {
       "path": "skills/self-review/references/domain-probes/equity_fairness.md",
@@ -3553,8 +3553,8 @@
     },
     {
       "path": "skills/self-review/references/domain-probes/observational_confounding.md",
-      "size": 33429,
-      "sha256": "ac1736047c069aa47df76deea92379cae407043b6989d8d3fc77db8fd84b0031"
+      "size": 34617,
+      "sha256": "ec4a11caed6d604e510437827f2b979fcf43ab1ddea6b298eb95673472b2b459"
     },
     {
       "path": "skills/self-review/references/domain-probes/polygenic_risk_score.md",
@@ -3588,8 +3588,8 @@
     },
     {
       "path": "skills/self-review/references/domain-probes/sr_ma.md",
-      "size": 17239,
-      "sha256": "486d569f559f16d62b882f7256ccfe7443e3e2b4cc72a407a5cd046162a98b25"
+      "size": 20154,
+      "sha256": "82ccb4abc1ab1fffaf528268baad6c79e67c9b2ff929c14d7dcccb9677e10ddc"
     },
     {
       "path": "skills/self-review/references/domain-probes/survey_research.md",
@@ -3658,8 +3658,8 @@
     },
     {
       "path": "skills/self-review/scripts/check_binning_consistency.py",
-      "size": 19541,
-      "sha256": "e3bf7dd2e0871ce6905abc1d33a26c7afac76a93d184bfe2d431af97d0622f74"
+      "size": 20076,
+      "sha256": "c6467eb4a1d954d67da87e283d8a628604a9ec7558c966f8b20c1b661e23b9c9"
     },
     {
       "path": "skills/self-review/scripts/check_citation_order.py",
@@ -3668,13 +3668,13 @@
     },
     {
       "path": "skills/self-review/scripts/check_claim_artifact.py",
-      "size": 13065,
-      "sha256": "ac29a7e8145152e6641fce8eaf98766cfc943a034db72252cc38538d7ab59db2"
+      "size": 15879,
+      "sha256": "1daa64eaabe493f05ae7e2129a2056b673ec588487d5b6c73f41f10104822935"
     },
     {
       "path": "skills/self-review/scripts/check_classical_style.py",
-      "size": 12210,
-      "sha256": "c973ee8b776f28515439fb185e1254e08e62c2e1410e260f18a824241a331af0"
+      "size": 13124,
+      "sha256": "941d90559cdcdd24f3eba58daf00eb34a7d227c3fe44267b93b65b80b6092989"
     },
     {
       "path": "skills/self-review/scripts/check_cohort_arithmetic.py",
@@ -3691,10 +3691,20 @@
       "size": 22032,
       "sha256": "42e0e9315e1c97ca0f9943213c65ea91d7064773d25287b2577f0386dfb7fc41"
     },
+    {
+      "path": "skills/self-review/scripts/check_emphasis_density.py",
+      "size": 6626,
+      "sha256": "79e517942c1eca4f879fa2b05e6497f93fe6f4d53ed58ca98e240bf5b44c4821"
+    },
+    {
+      "path": "skills/self-review/scripts/check_figure_citation.py",
+      "size": 5298,
+      "sha256": "342bc1126a420111da9c0fe38c6cd68cc45542b0e485202689d7219de9d80712"
+    },
     {
       "path": "skills/self-review/scripts/check_null_calibration.py",
-      "size": 7594,
-      "sha256": "9ddff01722c34efb6ffd757ae762c6ee12f5993bf13b11313c2e20b60b26cab3"
+      "size": 8585,
+      "sha256": "e5bd71c515554b3acbaefd3807e584364a536dc6e1101bec5b524bc26b341309"
     },
     {
       "path": "skills/self-review/scripts/check_panel_diversity.py",
@@ -3716,20 +3726,25 @@
       "size": 15481,
       "sha256": "c9cd8e47cfef1ffcea12ecda5314a71ccd5415f35f4f296addadf53ccb6ceb3b"
     },
+    {
+      "path": "skills/self-review/scripts/check_rounded_delta.py",
+      "size": 7079,
+      "sha256": "2961dd0b25dcd06f202442004e08f2d98c6f2d4c337be3f8b0e3286a59952072"
+    },
     {
       "path": "skills/self-review/scripts/check_scope_coherence.py",
-      "size": 10818,
-      "sha256": "820dfc264c2a4f62c79c0c7123a3e1a8b59a100b89654617a08ff55deeb25a75"
+      "size": 11920,
+      "sha256": "e600e54fcbe308060a8dadd871ec274b6ae19f89456ae0194490e152c0d09a91"
     },
     {
       "path": "skills/self-review/scripts/check_supplement_hygiene.py",
-      "size": 11088,
-      "sha256": "f89027472cdf0258357c3b0f0b0f3fec09b5ea65cc1373292797b818d1acf444"
+      "size": 13579,
+      "sha256": "c61bd5e485d2bce4a6efd7bf2a7980aa0d31ebecb876a7c6895fd12cb6bf7f1c"
     },
     {
       "path": "skills/self-review/skill.yml",
-      "size": 2223,
-      "sha256": "4009f3148776fab2096da3dad8a15e503c5073b4cc66b42c57498948e2040270"
+      "size": 2345,
+      "sha256": "91883d75f33ee873a6ebfbd4d5f2cf0c292d3b90fe4705d6a35e82a26ecf6523"
     },
     {
       "path": "skills/setup-medsci/SKILL.md",

package/metadata/distribution_manifest.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "medsci-skills",
-  "version": "5.9.2",
+  "version": "5.11.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/humanize/SKILL.md

@@ -178,6 +178,7 @@ If the density remains above 2.0, run another fix-verify cycle (max 3 rounds).
 | 19 | § (section sign) marker | "as in §2.3", "(see §Discussion)", "§Results" | Delete or replace with section name ("Methods", "Results") — `grep -c "§"` = 0 |
 | 20 | Methods/Results self-reference parenthetical | "(Methods §X)", "(Results §3.1)", "(Methods, Section 2.3)" | Drop the parenthetical or shorten to "(see Methods)" |
 | 21 | AI Disclosure boilerplate (body) | "## Artificial Intelligence Disclosure", "Generative AI was not used to create..." in manuscript body | Remove from body → place in cover letter / submission form only (per `~/.claude/rules/journal-ai-image-policies.md`) |
+| 25 | Inline-emphasis over-use (typographic over-signposting) | Single-word italics (*into*, *passive*, *same*), whole-clause italics (*a redesign of the relationship itself*), bold used mid-paragraph to signpost | Remove inline emphasis; keep only legitimate italics — statistical symbols (*P*, *t*, *n*), Latin (*in vivo*, *et al.*), gene/species (*BRCA1*). A bold **run-in subheading** at line start is fine (Nature/npj style) |
 
 ### Response-Letter Patterns (R2R)
 
@@ -247,6 +248,7 @@ the pass/fail status.
 | Pattern 19 — `§` symbol | ENFORCED (senior MA reviewer prep) | `grep -c "§" manuscript.md` > 0 | auto-strip; verify post-rewrite count == 0 |
 | Pattern 20 — `(see Methods §X)` self-reference | ENFORCED | match found | rewrite to direct section name reference |
 | Pattern 21 — AI Disclosure paragraph in body | ENFORCED | "Generative AI was not used..." paragraph in manuscript body | move to cover letter or remove |
+| Pattern 25 — inline-emphasis over-use | ENFORCED | italic-emphasis density over threshold after allowlist | run `/self-review` `scripts/check_emphasis_density.py --manuscript manuscript.md`; `EMPHASIS_OVERUSE` (Minor) means strip inline italics (keep only stat symbols / Latin / gene-species); whole-clause italics are the strongest tell |
 | Patterns 22-24 — R2R editing-mechanism / draft line-number / tooling leak | TRIAGE (response letters); `§` = 0 hard | detection greps in ai_patterns.md R2R section surface candidates | review each hit (analysis narration, quoted additions, revised-manuscript page/line are NOT tells); rewrite confirmed tells to substantive prose |
 | Citation preservation invariant | ENFORCED | any pre-existing `[@bibkey]` removed by rewrite | revert that single rewrite; flag for user |
 | Numerical preservation invariant | ENFORCED | any number changed by rewrite | revert; flag for user |

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